firefly-compiler 0.4.20 → 0.4.22

package/compiler/Resolver.ff

@@ -20,6 +20,12 @@ class ResolverState(
     mutable nextUnificationVariableIndex: Int
 )
 
+data CaseVariable(
+    at: Location
+    name: String
+    asBound: Option[String]
+)
+
 make(packagePair: PackagePair, moduleName: String, lspHook: LspHook): Resolver {
     Resolver(
         variables = [].toMap()
@@ -49,16 +55,16 @@ extend self: Resolver {
 
     resolveModule(module: Module, otherModules: List[Module]): Module {
         let moduleNamespace =
-            module.file.replace("\\", "/").reverse().takeWhile { _ != '/' }.reverse().takeWhile { _ != '.' }
+            module.file.replace("\\", "/").reverse().takeWhile {_ != '/'}.reverse().takeWhile {_ != '.'}
         let self2 = self.processImports(module.imports, otherModules)
         let self3 = self2.processDefinitions(module, None)
         let module2 = module.Module(
-            types = module.types.map { self3.resolveTypeDefinition(_) }
-            traits = module.traits.map { self3.resolveTraitDefinition(_) }
-            instances = module.instances.map { self3.resolveInstanceDefinition(_) }
-            extends = module.extends.map { self3.resolveExtendDefinition(_) }
-            lets = module.lets.map { self3.resolveLetDefinition(_, True) }
-            functions = module.functions.map { self3.resolveFunctionDefinition(_, True, False) }
+            types = module.types.map {self3.resolveTypeDefinition(_)}
+            traits = module.traits.map {self3.resolveTraitDefinition(_)}
+            instances = module.instances.map {self3.resolveInstanceDefinition(_)}
+            extends = module.extends.map {self3.resolveExtendDefinition(_)}
+            lets = module.lets.map {self3.resolveLetDefinition(_, True)}
+            functions = module.functions.map {self3.resolveFunctionDefinition(_, True, False)}
         )
         module2.instances.each {_.typeArguments.each {self3.checkInstanceType(_)}}
         module2
@@ -77,8 +83,8 @@ extend self: Resolver {
 
     processImports(imports: List[DImport], modules: List[Module]): Resolver {
         mutable resolver = self
-        imports.each { import =>
-            modules.find { _.file.dropLast(3) == import.file }.{
+        imports.each {import =>
+            modules.find {_.file.dropLast(3) == import.file}.{
                 | Some(module) =>
                     resolver = resolver.processDefinitions(module, Some(import.alias))
                 | None =>
@@ -95,7 +101,7 @@ extend self: Resolver {
                 module.file.dropLast(3) + "." + name
             importAlias.{
                 | None => [Pair(name, full), Pair(full, full)]
-                | Some(alias) { unqualified } => [Pair(alias + "." + name, full), Pair(name, full), Pair(full, full)]
+                | Some(alias) {unqualified} => [Pair(alias + "." + name, full), Pair(name, full), Pair(full, full)]
                 | Some(alias) => [Pair(alias + "." + name, full), Pair(full, full)]
             }
         }
@@ -103,20 +109,20 @@ extend self: Resolver {
             module.packagePair.group == "ff" &&
             module.packagePair.name == "core" &&
             module.file == "Core.ff"
-        let lets = module.lets.flatMap { entry(_.name, isCore) }.toMap()
-        let letLocations = module.lets.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}} }.toMap()
-        let functions = module.functions.flatMap { entry(_.signature.name, isCore) }.toMap()
+        let lets = module.lets.flatMap {entry(_.name, isCore)}.toMap()
+        let letLocations = module.lets.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}}}.toMap()
+        let functions = module.functions.flatMap {entry(_.signature.name, isCore)}.toMap()
         let functionLocations = module.functions.flatMap {d => entry(d.signature.name, True).map {_.mapSecond {_ => d.at}} }.toMap()
-        let traitMethods = module.traits.flatMap { _.methods }.flatMap { entry(_.name, False) }.toMap()
-        let traitMethodLocations = module.traits.flatMap {_.methods}.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}} }.toMap()
-        let traits = module.traits.flatMap { entry(_.name, True) }.toMap()
-        let traitLocations = module.traits.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}} }.toMap()
-        let types = module.types.flatMap { entry(_.name, True) }.toMap()
+        let traitMethods = module.traits.flatMap {_.methods }.flatMap {entry(_.name, False)}.toMap()
+        let traitMethodLocations = module.traits.flatMap {_.methods}.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}}}.toMap()
+        let traits = module.traits.flatMap {entry(_.name, True) }.toMap()
+        let traitLocations = module.traits.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}}}.toMap()
+        let types = module.types.flatMap {entry(_.name, True) }.toMap()
         let typeGenerics = module.types.flatMap {d => entry(d.name, True).map {p => Pair(p.first, d.generics)}}.toMap()
-        let typeLocations = module.types.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}} }.toMap()
-        let asyncTypes = module.types.filter { _.generics.first().any {_ == "Q$"} }
-            .flatMap { entry(_.name, True).map {_.first} }.toSet()
-        let variants = module.types.flatMap { _.variants }.flatMap { entry(_.name, True) }.toMap()
+        let typeLocations = module.types.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}}}.toMap()
+        let asyncTypes = module.types.filter {_.generics.first().any {_ == "Q$"}}
+            .flatMap {entry(_.name, True).map {_.first}}.toSet()
+        let variants = module.types.flatMap {_.variants }.flatMap {entry(_.name, True)}.toMap()
         self.Resolver(
             variables = self.variables.addAll(lets).addAll(functions).addAll(traitMethods)
             variableLocations = self.variableLocations.addAll(letLocations).addAll(functionLocations).addAll(traitMethodLocations)
@@ -135,7 +141,7 @@ extend self: Resolver {
     resolveTypeDefinition(definition: DType): DType {
         if(self.lspHook.isAt(definition.at)) {
             self.lspHook.emit(
-                ResolveSymbolHook(SymbolHook(definition.name, definition.at, definition.at), None)
+                ResolveSymbolHook(SymbolHook(definition.name, definition.at, definition.at), None, topLevel = True)
             )
         }
         let generics = definition.generics.map {g => Pair(g, g)}.toMap()
@@ -168,7 +174,7 @@ extend self: Resolver {
             variants = definition.variants.map {v =>
                 if(self.lspHook.isAt(v.at)) {
                     self.lspHook.emit(
-                        ResolveSymbolHook(SymbolHook(v.name, v.at, v.at), None)
+                        ResolveSymbolHook(SymbolHook(v.name, v.at, v.at), None, topLevel = True)
                     )
                 }
                 v.Variant(fields = v.fields.map {f =>
@@ -191,7 +197,7 @@ extend self: Resolver {
         if(self.lspHook.isAt(definition.at) || self.lspHook.isDefinedAt(definition.at)) {
             self.lspHook.emit(
                 ResolveSymbolHook(
-                    SymbolHook(definition.name, definition.at, definition.at), None
+                    SymbolHook(definition.name, definition.at, definition.at), None, topLevel = True
                 )
             )
         }        
@@ -221,7 +227,7 @@ extend self: Resolver {
         if(self.lspHook.isAt(definition.at) || self.lspHook.isDefinedAt(traitDefinedAt)) {
             self.lspHook.emit(
                 ResolveSymbolHook(
-                    SymbolHook(definition.traitName, definition.at, traitDefinedAt), None
+                    SymbolHook(definition.traitName, definition.at, traitDefinedAt), None, topLevel = True
                 )
             )
         }
@@ -266,7 +272,7 @@ extend self: Resolver {
         if(self.lspHook.isAt(definition.at) || self.lspHook.isDefinedAt(definition.at)) {
             self.lspHook.emit(
                 ResolveSymbolHook(
-                    SymbolHook(definition.name, definition.at, definition.at), None
+                    SymbolHook(definition.name, definition.at, definition.at), None, topLevel = topLevel
                 )
             )
         }
@@ -276,132 +282,134 @@ extend self: Resolver {
         )
     }
 
-    resolveTerm(term: Term, topLevel: Bool): Term {
-        | EString _, _ => term
-        | EChar _, _ => term
-        | EInt _, _ => term
-        | EFloat _, _ => term
-        | EVariable e, _ =>
-            if(self.lspHook.isEnabled()) {
-                let at = self.variableLocations.get(e.name).else {e.at}
-                if(self.lspHook.isAt(e.at) || self.lspHook.isDefinedAt(at)) {
-                    self.lspHook.emit(
-                        ResolveSymbolHook(
-                            SymbolHook(e.name, e.at, at), None
+    resolveTerm(term: Term, topLevel: Bool, inField: Bool = False): Term {
+        term.{
+            | EString _ => term
+            | EChar _ => term
+            | EInt _ => term
+            | EFloat _ => term
+            | EVariable e =>
+                if(self.lspHook.isEnabled()) {
+                    let at = self.variableLocations.get(e.name).else {e.at}
+                    if(self.lspHook.isAt(e.at) || self.lspHook.isDefinedAt(at)) {
+                        self.lspHook.emit(
+                            ResolveSymbolHook(
+                                SymbolHook(e.name, e.at, at), None, topLevel = True
+                            )
                         )
-                    )
+                    }
                 }
-            }
-            self.variables.get(e.name).map {e.EVariable(name = _)}.else {term}
-        | EList(at, t, items), _ =>
-            EList(at, self.resolveType(t, topLevel), items.map {| Pair(item, spread) =>
-                Pair(self.resolveTerm(item, topLevel), spread)
-            })
-        | EVariant(at, name, typeArguments, arguments), _ =>
-            EVariant(
-                at = at
-                name = self.variants.get(name).else {name}
-                typeArguments = typeArguments.map {self.resolveType(_, topLevel)}
-                arguments = arguments.map {_.map {a => a.Argument(value = self.resolveTerm(a.value, topLevel))}}
-            )
-        | EVariantIs(at, name, typeArguments), _ =>
-            EVariantIs(
-                at = at
-                name = self.variants.get(name).else { throw(CompileError(at, "No such variant: " + name)) }
-                typeArguments = typeArguments.map { self.resolveType(_, topLevel) }
-            )
-        | ECopy(at, name, record, arguments), _ =>
-            ECopy(
-                at = at
-                name = self.variants.get(name).else {name}
-                record = self.resolveTerm(record, topLevel)
-                arguments = arguments.map {f => f.Field(value = self.resolveTerm(f.value, topLevel))}
-            )
-        | EField e, _ =>
-            e.EField(record = self.resolveTerm(e.record, topLevel))
-        | ELambda(at, Lambda(lambdaAt, _, cases)), _ =>
-            let effect = self.makeEffectArgument(lambdaAt, topLevel)
-            ELambda(at, Lambda(lambdaAt, effect, cases.map {self.resolveCase(_, topLevel)}))
-        | EPipe(at, value, effect, function), _ =>
-            EPipe(
-                at = at
-                value = self.resolveTerm(value, topLevel)
-                effect = self.resolveType(effect, topLevel)
-                function = self.resolveTerm(function, topLevel)
-            )
-        | ECall(at, DynamicCall target, effect, typeArguments, arguments, dictionaries), _ =>
-            ECall(
-                at = at
-                target = target.DynamicCall(function = self.resolveTerm(target.function, topLevel))
-                effect = self.resolveType(effect, topLevel)
-                typeArguments = typeArguments.map {self.resolveType(_, topLevel)}
-                arguments = arguments.map {a => a.Argument(value = self.resolveTerm(a.value, topLevel))}
-                dictionaries = dictionaries
-            )
-        | ECall(at, StaticCall _, _, _, _, _), _ =>
-            throw(CompileError(at, "Internal error: Static calls not expected in the Resolver phase"))
-        | ERecord(at, fields), _ =>
-            ERecord(
-                at = at
-                fields = fields.map {f => f.Field(value = self.resolveTerm(f.value, topLevel))}
-            )
-        | EWildcard e, _ =>
-            if(e.index == 0) {throw(CompileError(e.at, "Unbound wildcard"))}
-            e.EWildcard()
-        | EFunctions(at, functions, body), _ =>
-            let functionMap = functions.map {_.signature.name}.map {name => Pair(name, name)}.toMap()
-            let locationMap = functions.map {_.signature}.map {s => Pair(s.name, s.at)}.toMap()
-            let self2 = self.Resolver(
-                variables = self.variables.addAll(functionMap)
-                variableLocations = self.variableLocations.addAll(locationMap)
-            )
-            EFunctions(
-                at = at
-                functions = functions.map {self2.resolveFunctionDefinition(_, topLevel, False)}
-                body = self2.resolveTerm(body, topLevel)
-            )
-        | ELet e, _ =>
-            let self2 = self.Resolver(
-                variables = self.variables.add(e.name, e.name)
-                variableLocations = self.variableLocations.add(e.name, e.at)
-            )
-            if(self.lspHook.isEnabled()) {
-                if(self.lspHook.isAt(e.at) || self.lspHook.isDefinedAt(e.at)) {
-                    self.lspHook.emit(
-                        ResolveSymbolHook(
-                            SymbolHook(e.name, e.at, e.at), None
+                self.variables.get(e.name).map {e.EVariable(name = _)}.else {term}
+            | EList(at, t, items) =>
+                EList(at, self.resolveType(t, topLevel), items.map {| Pair(item, spread) =>
+                    Pair(self.resolveTerm(item, topLevel), spread)
+                })
+            | EVariant(at, name, typeArguments, arguments) =>
+                EVariant(
+                    at = at
+                    name = self.variants.get(name).else {name}
+                    typeArguments = typeArguments.map {self.resolveType(_, topLevel)}
+                    arguments = arguments.map {_.map {a => a.Argument(value = self.resolveTerm(a.value, topLevel))}}
+                )
+            | EVariantIs(at, name, typeArguments) =>
+                EVariantIs(
+                    at = at
+                    name = self.variants.get(name).else {throw(CompileError(at, "No such variant: " + name))}
+                    typeArguments = typeArguments.map {self.resolveType(_, topLevel)}
+                )
+            | ECopy(at, name, record, arguments) =>
+                ECopy(
+                    at = at
+                    name = self.variants.get(name).else {name}
+                    record = self.resolveTerm(record, topLevel, inField = True)
+                    arguments = arguments.map {f => f.Field(value = self.resolveTerm(f.value, topLevel))}
+                )
+            | EField e =>
+                e.EField(record = self.resolveTerm(e.record, topLevel, inField = True))
+            | ELambda(at, Lambda(lambdaAt, _, cases)) =>
+                let effect = self.makeEffectArgument(lambdaAt, topLevel)
+                ELambda(at, Lambda(lambdaAt, effect, cases.map {self.resolveCase(_, topLevel)}))
+            | EPipe(at, value, effect, function) =>
+                EPipe(
+                    at = at
+                    value = self.resolveTerm(value, topLevel)
+                    effect = self.resolveType(effect, topLevel)
+                    function = self.resolveTerm(function, topLevel)
+                )
+            | ECall(at, DynamicCall target, effect, typeArguments, arguments, dictionaries) =>
+                ECall(
+                    at = at
+                    target = target.DynamicCall(function = self.resolveTerm(target.function, topLevel))
+                    effect = self.resolveType(effect, topLevel)
+                    typeArguments = typeArguments.map {self.resolveType(_, topLevel)}
+                    arguments = arguments.map {a => a.Argument(value = self.resolveTerm(a.value, topLevel))}
+                    dictionaries = dictionaries
+                )
+            | ECall(at, StaticCall _, _, _, _, _) =>
+                throw(CompileError(at, "Internal error: Static calls not expected in the Resolver phase"))
+            | ERecord(at, fields) =>
+                ERecord(
+                    at = at
+                    fields = fields.map {f => f.Field(value = self.resolveTerm(f.value, topLevel))}
+                )
+            | EWildcard e =>
+                if(e.index == 0) {throw(CompileError(e.at, "Unbound wildcard"))}
+                e.EWildcard()
+            | EFunctions(at, functions, body) =>
+                let functionMap = functions.map {_.signature.name}.map {name => Pair(name, name)}.toMap()
+                let locationMap = functions.map {_.signature}.map {s => Pair(s.name, s.at)}.toMap()
+                let self2 = self.Resolver(
+                    variables = self.variables.addAll(functionMap)
+                    variableLocations = self.variableLocations.addAll(locationMap)
+                )
+                EFunctions(
+                    at = at
+                    functions = functions.map {self2.resolveFunctionDefinition(_, topLevel, False)}
+                    body = self2.resolveTerm(body, topLevel)
+                )
+            | ELet e =>
+                let self2 = self.Resolver(
+                    variables = self.variables.add(e.name, e.name)
+                    variableLocations = self.variableLocations.add(e.name, e.at)
+                )
+                if(self.lspHook.isEnabled()) {
+                    if(self.lspHook.isAt(e.at) || self.lspHook.isDefinedAt(e.at)) {
+                        self.lspHook.emit(
+                            ResolveSymbolHook(
+                                SymbolHook(e.name, e.at, e.at), None, topLevel = False
+                            )
                         )
-                    )
-                }
-            }
-            e.ELet(
-                valueType = self.resolveType(e.valueType, topLevel)
-                value = self.resolveTerm(e.value, topLevel)
-                body = self2.resolveTerm(e.body, topLevel)
-            )
-        | ESequential(at, before, after), _ =>
-            ESequential(
-                at = at
-                before = self.resolveTerm(before, topLevel)
-                after = self.resolveTerm(after, topLevel)
-            )
-        | EAssign(at, operator, variable, value), _ =>
-            EAssign(
-                at = at
-                operator = operator
-                variable = self.variables.get(variable).else {
-                    throw(CompileError(at, "No such variable: " + variable))
+                    }
                 }
-                value = self.resolveTerm(value, topLevel)
-            )
-        | EAssignField(at, operator, record, field, value), _ =>
-            EAssignField(
-                at = at
-                operator = operator
-                record = self.resolveTerm(record, topLevel)
-                field = field
-                value = self.resolveTerm(value, topLevel)
-            )
+                e.ELet(
+                    valueType = self.resolveType(e.valueType, topLevel)
+                    value = self.resolveTerm(e.value, topLevel)
+                    body = self2.resolveTerm(e.body, topLevel)
+                )
+            | ESequential(at, before, after) =>
+                ESequential(
+                    at = at
+                    before = self.resolveTerm(before, topLevel)
+                    after = self.resolveTerm(after, topLevel)
+                )
+            | EAssign(at, operator, variable, value) =>
+                EAssign(
+                    at = at
+                    operator = operator
+                    variable = self.variables.get(variable).else {
+                        throw(CompileError(at, "No such variable: " + variable))
+                    }
+                    value = self.resolveTerm(value, topLevel)
+                )
+            | EAssignField(at, operator, record, field, value) =>
+                EAssignField(
+                    at = at
+                    operator = operator
+                    record = self.resolveTerm(record, topLevel)
+                    field = field
+                    value = self.resolveTerm(value, topLevel)
+                )
+        }
     }
 
     resolveType(type: Type, topLevel: Bool): Type {
@@ -492,7 +500,7 @@ extend self: Resolver {
     resolveSignature(signature: Signature, topLevel: Bool, isInstanceMethod: Bool): Signature {
         if(self.lspHook.isAt(signature.at) || self.lspHook.isDefinedAt(signature.at)) {
             self.lspHook.emit(
-                ResolveSignatureHook(signature, isInstanceMethod)
+                ResolveSignatureHook(signature, isInstanceMethod, topLevel = topLevel)
             )
         }
         let newSignature = if(topLevel) {
@@ -535,7 +543,7 @@ extend self: Resolver {
     }
 
     resolveCase(case: MatchCase, topLevel: Bool): MatchCase {
-        function findVariables(pattern: MatchPattern): Map[String, Pair[Location, String]] {
+        function findVariables(pattern: MatchPattern): Map[String, CaseVariable] {
             | PString _ =>
                 Map.empty()
             | PInt _ =>
@@ -543,22 +551,22 @@ extend self: Resolver {
             | PChar _ =>
                 Map.empty()
             | PVariable(at, Some(name)) =>
-                [Pair(name, Pair(at, name))].toMap()
+                [Pair(name, CaseVariable(at, name, None))].toMap()
             | PVariable(_, None) =>
                 Map.empty()
             | PVariant(_, _, patterns) =>
                 patterns.map(findVariables).foldLeft(Map.empty()) {_.addAll(_)}
-            | PVariantAs(at, _, variableAt, variable) =>
-                variable.toList().map {x => Pair(x, Pair(variableAt, x))}.toMap()
+            | PVariantAs(at, variant, variableAt, variable) =>
+                variable.toList().map {x => Pair(x, CaseVariable(variableAt, x, Some(variant)))}.toMap()
             | PAlias(at, pattern, variable) =>
-                [Pair(variable, Pair(at, variable))].toMap().addAll(findVariables(pattern))
+                [Pair(variable, CaseVariable(at, variable, None))].toMap().addAll(findVariables(pattern))
         }
         let variableMap = case.patterns.map(findVariables).foldLeft(Map.empty()) {_.addAll(_)}
         mutable guards = []
         let variableMap2 = case.guards.foldLeft(variableMap) {variableMap1, g =>
             let self2 = self.Resolver(
-                variables = self.variables.addAll(variableMap1.mapValues {_, p => p.second})
-                variableLocations = self.variableLocations.addAll(variableMap1.mapValues {_, p => p.first})
+                variables = self.variables.addAll(variableMap1.mapValues {_, p => p.name})
+                variableLocations = self.variableLocations.addAll(variableMap1.mapValues {_, p => p.at})
             )
             let guard = g.MatchGuard(
                 term = self2.resolveTerm(g.term, topLevel)
@@ -568,8 +576,8 @@ extend self: Resolver {
             variableMap1.addAll(findVariables(guard.pattern))
         }
         let self3 = self.Resolver(
-            variables = self.variables.addAll(variableMap2.mapValues {_, p => p.second})
-            variableLocations = self.variableLocations.addAll(variableMap2.mapValues {_, p => p.first})
+            variables = self.variables.addAll(variableMap2.mapValues {_, p => p.name})
+            variableLocations = self.variableLocations.addAll(variableMap2.mapValues {_, p => p.at})
         )
         MatchCase(
             at = case.at

package/compiler/Substitution.ff

@@ -154,9 +154,9 @@ extend self: Substitution {
 
     substituteType(type: Type): Type {
         | TVariable(at, i) =>
-            if(self.has(i)) { self.substituteType(self.get(i)) } else { TConstructor(at, core("Nothing"), []) }
+            if(self.has(i)) {self.substituteType(self.get(i))} else {TConstructor(at, core("Nothing"), [])}
         | TConstructor t =>
-            t.TConstructor(generics = t.generics.map { t => self.substituteType(t) })
+            t.TConstructor(generics = t.generics.map {g => self.substituteType(g)})
     }
 
     get(index: Int): Type {

package/compiler/Syntax.ff

@@ -9,6 +9,7 @@ extend self: Location {
 }
 
 data CompileError(at: Location, message: String)
+data CompileErrors(errors: List[CompileError])
 
 data ModuleWithPackageInfo(
     packageInfo: Option[PackageInfo]

package/compiler/Unification.ff

@@ -152,7 +152,7 @@ extend self: Unification {
     substitute(type: Type): Type {
         | TVariable(_, i) {self.get(i) | Some(t)} => self.substitute(t)
         | TVariable(_, _) => type
-        | TConstructor t => t.TConstructor(generics = t.generics.map {t => self.substitute(t)})
+        | TConstructor t => t.TConstructor(generics = t.generics.map {g => self.substitute(g)})
     }
 
     unify(at: Location, t1: Type, t2: Type): Unit {

package/core/Array.ff

@@ -35,10 +35,7 @@ extend self[T]: Array[T] {
 
     grab(index: Int): T
         target js sync """
-            if(index_ < 0 || index_ >= self_.array.length) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            return self_.array[index_]
+            return self_.array[index_] ?? internalGrab_(self_, index_);
         """
 
     grabFirst(): T {self.grab(0)}
@@ -261,3 +258,8 @@ sortRange[T](array: Array[T], compare: (T, T) => Ordering, start: Int, end: Int)
         }
     }
 }
+
+internalGrab[T](self: Array[T], index: Int): T
+    target js sync """
+        return index_ < 0 || index_ >= self_.array.length ? ff_core_Try.internalThrowGrabException_() : self_.array[index_];
+    """

package/core/Int.ff

@@ -27,23 +27,23 @@ extend self: Int {
         target js sync "return signed_ ? self_ >> bits_ : self_ >>> bits_;"
 
     to(inclusiveEnd: Int): List[Int] {
-        mutable result = []
-        mutable n = inclusiveEnd
-        while {self <= n} {
-            result = [n, ...result]
-            n -= 1
+        let result = Array.make()
+        mutable n = self
+        while {n <= inclusiveEnd} {
+            result.push(n)
+            n += 1
         }
-        result
+        result.drain()
     }
 
     until(exclusiveEnd: Int): List[Int] {
-        mutable result = []
-        mutable n = exclusiveEnd
-        while {self < n} {
-            result = [n - 1, ...result]
-            n -= 1
+        let result = Array.make()
+        mutable n = self
+        while {n < exclusiveEnd} {
+            result.push(n)
+            n += 1
         }
-        result
+        result.drain()
     }
 
     min(that: Int): Int {

package/core/List.ff

@@ -47,10 +47,7 @@ extend self[T]: List[T] {
 
     grab(index: Int): T
         target js sync """
-            if(index_ < 0 || index_ >= self_.length) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            return self_[index_]
+            return self_[index_] ?? internalGrab_(self_, index_);
         """
 
     first(): Option[T] {self.get(0)}
@@ -411,3 +408,8 @@ instance List[T: Order]: Order {
 
 internalSame[T](left: List[T], right: List[T]): Bool
     target js sync "return left_ === right_"
+
+internalGrab[T](self: List[T], index: Int): T
+    target js sync """
+        return index_ < 0 || index_ >= self_.length ? ff_core_Try.internalThrowGrabException_() : self_[index_];
+    """

package/core/Map.ff

@@ -18,6 +18,14 @@ extend self[K: Order, V]: Map[K, V] {
         Map(result)
     }
 
+    addList(that: List[Pair[K, V]]): Map[K, V] {
+        mutable result = self.redBlack
+        that.each {| Pair(k, v) =>
+            result = RbMap.insert(k, v, result)
+        }
+        Map(result)
+    }
+
     get(key: K): Option[V] {
         self.redBlack.get(key)
     }

package/core/Set.ff

@@ -7,6 +7,13 @@ empty[T](): Set[T] {
 extend self[T: Order]: Set[T] {
     add(value: T): Set[T] {Set(self.map.add(value, Unit))}
     addAll(that: Set[T]): Set[T] {Set(self.map.addAll(that.map))}
+    addList(that: List[T]): Set[T] {
+        mutable result = self.map
+        that.each {k =>
+            result = result.add(k, Unit)
+        }
+        Set(result)        
+    }
     remove(value: T): Set[T] {Set(self.map.remove(value))}
     removeAll(that: Set[T]): Set[T] {Set(self.map.removeAll(that.map))}
     contains(value: T): Bool {self.map.contains(value)}

package/experimental/benchmarks/ListGrab.ff

@@ -0,0 +1,23 @@
+nodeMain(system: NodeSystem) {
+    let list = 1.to(10000)
+    benchmark(list, 100000)
+    let time = system.mainTask().time {
+        benchmark(list, 100000)
+    }
+    Log.trace(time.second.show())
+}
+
+benchmark(list: List[Int], iterations: Int): Int {
+    mutable sum = 0
+    mutable i = 0
+    while {i < iterations} {
+        mutable j = 0
+        sum = 0
+        while {j < 10000} {
+            sum += list.grab(j)
+            j += 1
+        }
+        i += 1
+    }
+    sum
+}