| career | drupal | java | mac | mysql | perl | scala | uml | unix  

Scala example source code file (ReplVals.scala)

This example Scala source code file (ReplVals.scala) is included in my "Source Code Warehouse" project. The intent of this project is to help you more easily find Scala source code examples by using tags.

All credit for the original source code belongs to; I'm just trying to make examples easier to find. (For my Scala work, see my Scala examples and tutorials.)

Scala tags/keywords

appliedtypefromtags, compiler, global, iloop, nosymbol, notype, nsc, reflection, replimplicits, replvals, runtime, symbol, t, type

The ReplVals.scala Scala example source code

/* NSC -- new Scala compiler
 * Copyright 2005-2013 LAMP/EPFL
 * @author Paul Phillips

package interpreter

import scala.language.implicitConversions
import scala.reflect.api.{Universe => ApiUniverse}
import scala.reflect.runtime.{universe => ru}

/** A class which the repl utilizes to expose predefined objects.
 *  The base implementation is empty; the standard repl implementation
 *  is StdReplVals.
abstract class ReplVals { }

class StdReplVals(final val r: ILoop) extends ReplVals {
  final lazy val repl                     = r
  final lazy val intp                     = r.intp
  final lazy val power                    = r.power
  final lazy val reader                   =
  final lazy val vals                     = this
  final lazy val global: =
  final lazy val isettings                = intp.isettings
  final lazy val completion               = reader.completion
  final lazy val history                  = reader.history
  final lazy val phased                   = power.phased
  final lazy val analyzer                 = global.analyzer

  object treedsl extends { val global: = } with ast.TreeDSL { }

  final lazy val typer = analyzer.newTyper(
  def lastRequest = intp.lastRequest

  class ReplImplicits extends power.Implicits2 {

    private val tagFn = ReplVals.mkCompilerTypeFromTag[](global)
    implicit def mkCompilerTypeFromTag(sym: Symbol) = tagFn(sym)

  final lazy val replImplicits = new ReplImplicits

  def typed[T <:](tree: T): T = typer.typed(tree).asInstanceOf[T]

object ReplVals {
  /** Latest attempt to work around the challenge of
   *  not being seen as the same type as even though
   *  the globals are the same.  Dependent method types to the rescue.
  def mkCompilerTypeFromTag[T <: Global](global: T) = {
    import global._

    /** We can't use definitions.compilerTypeFromTag directly because we're passing
     *  it to map and the compiler refuses to perform eta expansion on a method
     *  with a dependent return type.  (Can this be relaxed?) To get around this
     *  I have this forwarder which widens the type and then cast the result back
     *  to the dependent type.
    def compilerTypeFromTag(t: ApiUniverse # WeakTypeTag[_]): Global#Type =

    class AppliedTypeFromTags(sym: Symbol) {
      def apply[M](implicit m1: ru.TypeTag[M]): Type =
        if (sym eq NoSymbol) NoType
        else appliedType(sym, compilerTypeFromTag(m1).asInstanceOf[Type])

      def apply[M1, M2](implicit m1: ru.TypeTag[M1], m2: ru.TypeTag[M2]): Type =
        if (sym eq NoSymbol) NoType
        else appliedType(sym, compilerTypeFromTag(m1).asInstanceOf[Type], compilerTypeFromTag(m2).asInstanceOf[Type])

    (sym: Symbol) => new AppliedTypeFromTags(sym)

Other Scala source code examples

Here is a short list of links related to this Scala ReplVals.scala source code file:

... this post is sponsored by my books ...

#1 New Release!

FP Best Seller


new blog posts


Copyright 1998-2021 Alvin Alexander,
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.