firefly-compiler 0.4.4

package/compiler/Tokenizer.ff

@@ -0,0 +1,278 @@
+import Token
+import Syntax
+import LspHook
+
+tokenize(file: String, code: String, completionAt: Option[Location], attemptFixes: Bool): Array[Token] {
+
+    let completionLine = completionAt.filter {_.file == file}.map {_.line}.else {-1}
+    let completionColumn = completionAt.filter {_.file == file}.map {_.column}.else {-1}
+
+    let tokens = Stack.make[Token]()
+    mutable line = 1
+    mutable lineOffset = 0
+
+    mutable startLine = line
+    mutable startLineOffset = lineOffset
+
+    let operatorCharactersString = "!@#$%&/=?+|^~*<>.:-;"
+    mutable operatorCharacters = Set.empty[Char]()
+    List.range(operatorCharactersString.size()).map {j =>
+        operatorCharacters = operatorCharacters.add(operatorCharactersString.grab(j))
+    }
+
+    function emitToken(kind: TokenKind, startOffset: Int, stopOffset: Int): Unit {
+        if(!tokens.isEmpty()) {
+            let last = tokens.grabLast()
+            if(last.stopLine == startLine && last.kind == LLower && kind.afterKeyword()) {
+                if(
+                    completionLine == last.startLine && 
+                    completionColumn >= 1 + last.startOffset - last.startLineOffset &&
+                    completionColumn <= 1 + last.stopOffset - last.stopLineOffset
+                ) {
+                    tokens.push(Token(
+                        file, code, LSeparator
+                        startLine, startLineOffset, startLineOffset
+                        startLine, startLineOffset, startLineOffset
+                    ))
+                } else {
+                    tokens.modify(tokens.size() - 1) {_.Token(kind = LKeyword)}
+                }
+            }
+            if(last.stopLine != startLine && last.kind.beforeSeparator() && kind.afterSeparator()) {
+                tokens.push(Token(
+                    file, code, LSeparator
+                    startLine, startLineOffset, startLineOffset
+                    startLine, startLineOffset, startLineOffset
+                ))
+            }
+        }
+        tokens.push(Token(
+            file, code, kind
+            startLine, startLineOffset, startOffset
+            line, lineOffset, stopOffset
+        ))
+    }
+
+    mutable i = 0
+
+    function throwError(message: String) {
+        let column = (i - startLineOffset) + 1
+        throw(CompileError(
+            Location(file, line, column)
+            message
+        ))
+    }
+
+    try {
+        while {i < code.size()} {
+
+            startLine = line
+            startLineOffset = lineOffset
+
+            if(completionLine == line) {
+                while {i < code.size() && (code.grab(i) == ' ' || code.grab(i) == '\t' || code.grab(i) == '\r')} {
+                    if(completionColumn == 1 + i - lineOffset) {
+                        emitToken(LLower, i, i)
+                    }
+                    i += 1
+                }
+                if(i < code.size() && completionColumn == 1 + i - lineOffset) {
+                    let c = code.grab(i)
+                    if(!c.isAsciiLetterOrDigit() && c != '_' && c != '\'' && c != '"') {
+                        emitToken(LLower, i, i)
+                        if(i + 1 < code.size() && code.grab(i) == '_') {i += 1}
+                    }
+                }
+                Unit // Think about how to avoid requiring this
+            } else {
+                while {i < code.size() && (code.grab(i) == ' ' || code.grab(i) == '\t' || code.grab(i) == '\r')} {i += 1}
+            }
+            
+            if(i < code.size()):
+
+            let start = i
+
+            if(code.grab(i) == '\n') {
+
+                i += 1
+                line += 1
+                lineOffset = i
+
+            } elseIf {code.grab(i) == '/' && code.grab(i + 1) == '/'} {
+
+                i += 2
+                while {i < code.size() && code.grab(i) != '\n'} {i += 1}
+
+            } elseIf {code.grab(i) == '/' && code.grab(i + 1) == '*'} {
+
+                i += 2
+                while {i < code.size() && (code.grab(i) != '*' || code.grab(i + 1) != '/')} {
+                    if(i >= code.size()) {
+                        throwError(
+                            "Expected end of comment started on line " + startLine + ", got end of file."
+                        )
+                    }
+                    if(code.grab(i) == '\n') {
+                        line += 1
+                        lineOffset = i + 1
+                    }
+                    i += 1
+                }
+                i += 2
+
+            } elseIf {code.grab(i) == '"' || code.grab(i) == '\''} {
+
+                let endSign = code.grab(i)
+
+                mutable multiLine = i + 2 < code.size() &&
+                    code.grab(i) == '"' && code.grab(i + 1) == '"' && code.grab(i + 2) == '"'
+
+                i += if(multiLine) {3} else {1}
+                while {i < code.size() && (multiLine || code.grab(i) != endSign)} {
+                    if(code.grab(i) == '\n') {
+                        if(multiLine) {
+                            line += 1
+                            lineOffset = i + 1
+                        } else {
+                            throwError(
+                                "Unexpected end of line in string."
+                            )
+                        }
+                    }
+                    if(i >= code.size()) {
+                        throwError(
+                            "Expected end of string started on line " + startLine + ", got end of file."
+                        )
+                    }
+                    if(code.grab(i) == '\\' && code.grab(i + 1) != '\n') {i += 1}
+                    if(multiLine &&
+                        i + 2 < code.size() && (i + 3 >= code.size() || code.grab(i + 3) != '"') &&
+                        code.grab(i) == '"' && code.grab(i + 1) == '"' && code.grab(i + 2) == '"'
+                    ) {
+                        multiLine = False
+                        i += 2
+                    } else {
+                        i += 1
+                    }
+                }
+                i += 1
+                emitToken(if(endSign == '"') {LString} else {LChar}, start, i)
+
+            } elseIf {code.grab(i).isAsciiLetter()} {
+
+                let kind = if(code.grab(i) >= 'a') {LLower} else {LUpper}
+                i += 1
+                while {i < code.size() && code.grab(i).isAsciiLetterOrDigit()} {i += 1}
+                if(i < code.size() && kind == LUpper && code.grab(i) == '.') {
+                    i += 1
+                    emitToken(LNamespace, start, i)
+                } else {
+                    emitToken(kind, start, i)
+                }
+
+            } elseIf {code.grab(i).isAsciiDigit()} {
+
+                mutable dot = False
+                mutable exponent = False
+                while {i < code.size() && code.grab(i).isAsciiDigit()} {
+                    i += 1
+                    if((code.grab(i) == 'e' || code.grab(i) == 'E') && !exponent) {
+                        i += 1
+                        dot = True
+                        exponent = True
+                        if(code.grab(i) == '+' || code.grab(i) == '-') {i += 1}
+                    }
+                    if(
+                        i + 1 < code.size() && code.grab(i) == '.' &&
+                        code.grab(i + 1).isAsciiDigit() &&
+                        !dot && !exponent
+                    ) {
+                        i += 1
+                        dot = True
+                    }
+                }
+                emitToken(if(dot || exponent) {LFloat} else {LInt}, start, i)
+
+            } elseIf {code.grab(i) == '_'} {
+
+                i += 1
+                emitToken(LWildcard, start, i)
+
+            } elseIf {code.grab(i) == ','} {
+
+                i += 1
+                emitToken(LComma, start, i)
+
+            } elseIf {operatorCharacters.contains(code.grab(i))} {
+
+                i += 1
+                
+                if(code.grab(i - 1) == '.' && i + 1 < code.size() && code.grab(i) == '.' && code.grab(i + 1) != '.') {
+                    emitToken(LDot, start, i)
+                    let newStart = i
+                    if(!completionAt.isEmpty()) {emitToken(LLower, newStart, newStart)}
+                    i += 1
+                    emitToken(LDot, newStart, i)
+                } else:
+
+                while {i < code.size() && operatorCharacters.contains(code.grab(i))} {i += 1}
+                let o =
+                    if(i - start == 1 && code.grab(i - 1) == '.') {
+                        LDot
+                    } elseIf {i - start == 1 && code.grab(i - 1) == ';'} {
+                        LSemicolon
+                    } elseIf {i - start == 1 && code.grab(i - 1) == '|'} {
+                        LPipe
+                    } elseIf {i - start == 1 && code.grab(i - 1) == ':'} {
+                        LColon
+                    } elseIf {i - start == 3 && code.grab(i - 3) == '.' && code.grab(i - 2) == '.' && code.grab(i - 1) == '.'} {
+                        LDotDotDot
+                    } elseIf {i - start == 2 && code.grab(i - 2) == '=' && code.grab(i - 1) == '>'} {
+                        LArrowThick
+                    } elseIf {i - start == 1 && code.grab(i - 1) == '='} {
+                        LAssign
+                    } elseIf {i - start == 2 && code.grab(i - 2) == '+' && code.grab(i - 1) == '='} {
+                        LAssignPlus
+                    } elseIf {i - start == 2 && code.grab(i - 2) == '-' && code.grab(i - 1) == '='} {
+                        LAssignMinus
+                    } elseIf {i - start == 3 && code.grab(i - 3) == ':' && code.grab(i - 2) == ':' && code.grab(i - 1) == '='} {
+                        LAssignLink
+                    } else {
+                        LOperator
+                    }
+
+                emitToken(o, start, i)
+
+            } elseIf {
+                code.grab(i) == '(' || code.grab(i) == '[' || code.grab(i) == '{'
+            } {
+
+                i += 1
+                emitToken(LBracketLeft, start, i)
+
+            } elseIf {
+                code.grab(i) == ')' || code.grab(i) == ']' || code.grab(i) == '}'
+            } {
+
+                i += 1
+                emitToken(LBracketRight, start, i)
+
+            } elseIf {
+                i < code.size()
+            } {
+
+                if(attemptFixes) {i += 1} else:
+                throwError("Unexpected character: " + Show.show(code.grab(i)))
+
+            }
+
+        }
+    } catch {| GrabException e, error =>
+        throw(CompileError(Location(file, line, i - lineOffset), "Unexpected end of file"))
+    } grab()
+
+    List.range(5).each {_ => emitToken(LEnd, i, i) }
+
+    tokens.drain()
+
+}

package/compiler/Unification.ff

@@ -0,0 +1,220 @@
+import Syntax
+import Inference
+
+class Unification(
+    mutable substitution: Map[Int, Type]
+    mutable constraints: Map[Int, Map[String, ConstraintGenerics]]
+    mutable nextUnificationVariableIndex: Int
+    mutable instances: Map[InstanceKey, InstanceValue]
+    mutable affects: Map[Int, Set[Int]]
+    attemptFixes: Bool
+)
+
+data ConstraintGenerics(at: Location, generics: List[Type])
+
+data InstanceKey(traitName: String, typeName: String)
+
+data InstanceValue(
+    generics: List[String]
+    constraints: List[Constraint]
+    packagePair: PackagePair
+    moduleName: String
+    traitName: String
+    typeArguments: List[Type]
+)
+
+fail[T](at: Location, message: String): T {
+    throw(CompileError(at, message))
+}
+
+make(modules: List[Module], attemptFixes: Bool): Unification {
+
+    Unification(
+        Map.empty()
+        Map.empty()
+        3 // To avoid collision with the parser and resolver
+        modules.flatMap {module =>
+            let moduleName = module.file.dropLast(".ff".size())
+            module.instances.map {definition =>
+                let typeName = definition.typeArguments.grabFirst().{
+                    | TConstructor(_, name, _) => name
+                    | TVariable(_, i) => fail(definition.at, "Unexpected unification variable: $" + i)
+                }
+                Pair(
+                    InstanceKey(definition.traitName, typeName)
+                    InstanceValue(
+                        generics = definition.generics
+                        constraints = definition.constraints
+                        packagePair = module.packagePair
+                        moduleName = moduleName
+                        traitName = definition.traitName
+                        typeArguments = definition.typeArguments
+                    )
+                )
+            }
+        }.toMap()
+        [].toMap()
+        attemptFixes
+    )
+}
+
+extend self: Unification {
+
+    withLocalInstances[T](instances: Map[InstanceKey, InstanceValue], body: () => T): T {
+        let oldInstances = self.instances
+        self.instances = self.instances.addAll(instances)
+        try {
+            body()
+        } finally {
+            self.instances = oldInstances
+        } grab()
+    }
+
+    freshUnificationVariable(at: Location): Type {
+        let result = TVariable(at, self.nextUnificationVariableIndex)
+        self.nextUnificationVariableIndex += 3
+        result
+    }
+
+    instantiate(instantiation: Map[String, Type], type: Type): Type {
+        | _, TConstructor(at, name, []) =>
+            instantiation.get(name).{
+                | Some(t) => t
+                | None => type
+            }
+        | _, TConstructor(at, name, generics) =>
+            TConstructor(at, name, generics.map {self.instantiate(instantiation, _)})
+        | _, TVariable(_, i) {self.get(i) | Some(t)} =>
+            self.instantiate(instantiation, t)
+        | _, TVariable(_, i) =>
+            type
+    }
+    
+    instantiateConstraint(instantiation: Map[String, Type], constraint: Constraint): Constraint {
+        | _, Constraint(at, name, generics) =>
+            Constraint(at, name, generics.map {self.instantiate(instantiation, _)})
+    }
+
+    constrain(at: Location, type: Type, constraintName: String, generics: List[Type]): Unit {
+        type.{
+            | TVariable(_, i) {self.get(i) | Some(t)} =>
+                self.constrain(at, t, constraintName, generics)
+            | TVariable(_, i) =>
+                self.constraints.get(i).{
+                    | None =>
+                        self.constraints = self.constraints.add(
+                            i, [Pair(constraintName, ConstraintGenerics(at, generics))].toMap()
+                        )
+                    | Some(map) =>
+                        map.get(constraintName).{
+                            | None =>
+                                let newMap = map.add(constraintName, ConstraintGenerics(at, generics))
+                                self.constraints = self.constraints.add(i, newMap)
+                            | Some(ConstraintGenerics(_, generics2)) =>
+                                generics.zip(generics2).each {| Pair(t1, t2) => self.unify(at, t1, t2) }
+                        }
+                }
+            | TConstructor(_, name, generics2) =>
+                self.instances.get(InstanceKey(constraintName, name)).{
+                    | None =>
+                        let g1 = if(generics.isEmpty()) {""} else {"[...]"}
+                        let g2 = if(generics2.isEmpty()) {""} else {"[...]"}
+                        if(!self.attemptFixes) {
+                            throw(CompileError(at, "No such instance: " + name + g2 + ": " + constraintName + g1))
+                        }
+                    | Some(definition) =>
+                        let unificationVariables = definition.generics.map {_ => self.freshUnificationVariable(at) }
+                        let instantiation = definition.generics.zip(unificationVariables).toMap()
+                        let traitType1 = self.instantiate(instantiation,
+                            TConstructor(at, definition.traitName, definition.typeArguments)
+                        )
+                        let traitType2 = TConstructor(at, constraintName, [type, ...generics])
+                        self.unify(at, traitType1, traitType2)
+                        definition.constraints.each {constraint =>
+                            self.instantiateConstraint(instantiation, constraint).{
+                                | Constraint(_, constraintName, newGenerics) =>
+                                    self.constrain(at, newGenerics.grabFirst(), constraintName, newGenerics.dropFirst())
+                            }
+                        }
+                }
+        }
+    }
+
+    get(index: Int): Option[Type] {
+        self.substitution.get(index).map {
+            | TVariable(_, i) {self.substitution.get(i) | Some(t)} =>
+                self.substitution = self.substitution.add(index, t)
+                t
+            | t => t
+        }
+    }
+
+    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)})
+    }
+
+    unify(at: Location, t1: Type, t2: Type): Unit {
+        | _, TVariable(_, i1), TVariable(_, i2) {i1 == i2} =>
+        | _, TVariable(_, i), _ {self.get(i) | Some(t)} => self.unify(at, t, t2)
+        | _, _, TVariable(_, i) {self.get(i) | Some(t)} => self.unify(at, t1, t)
+        | _, TVariable(_, i), _ => self.bind(at, i, t2)
+        | _, _, TVariable(_, i) => self.bind(at, i, t1)
+        | _, TConstructor(_, name1, generics1), TConstructor(_, name2, generics2) =>
+            if(name1 != name2 || generics1.size() != generics2.size()) {
+                if(!self.attemptFixes) {
+                    let t3 = self.substitute(t1)
+                    let t4 = self.substitute(t2)
+                    throw(CompileError(at
+                        "Type mismatch: " + t3.show([t3, t4]) + " vs. " + t4.show([t3, t4])
+                    ))
+                } elseIf {name1.startsWith("Function$") && name2.startsWith("Function$")} {
+                    generics1.dropLast().zip(generics2.dropLast()).each {| Pair(t3, t4) => self.unify(at, t3, t4)}
+                    generics1.takeLast().zip(generics2.takeLast()).each {| Pair(t3, t4) => self.unify(at, t3, t4)}
+                }
+                Unit // TODO: Think about how to avoid writing this
+            } else {
+                generics1.zip(generics2).each {| Pair(t1, t2) => self.unify(at, t1, t2) }
+            }
+    }
+
+    bind(at: Location, index: Int, type: Type): Unit {
+        if(self.occursIn(index, type)) {
+            let t = self.substitute(type)
+            throw(CompileError(at, "Infinite type: " + TVariable(at, index).show([t]) + " = " + t.show([])))
+        }
+        self.substitution = self.substitution.add(index, type)
+        self.constraints.get(index).each {map =>
+            self.constraints = self.constraints.remove(index)
+            map.pairs().each {| Pair(name, ConstraintGenerics(at2, generics)) =>
+                self.constrain(at2, type, name, generics)
+            }
+        }
+        self.affects.get(index).each {affected =>
+            self.affects.remove(index)
+            affected.each {i =>
+                self.affect(at, type, TVariable(at, i))
+            }
+        }
+    }
+
+    affect(at: Location, source: Type, target: Type): Unit {
+        Pair(self.substitute(source), self.substitute(target)).{
+            | Pair(TVariable(_, i1), TVariable(_, i2)) =>
+                let is = self.affects.get(i1).else([].toSet)
+                self.affects = self.affects.add(i1, is.add(i2))
+            | Pair(_, TConstructor(_, "Q$", _)) =>
+            | Pair(TConstructor(_, "ff:core/Nothing.Nothing", _), _) =>
+            | Pair(t1, t2) =>
+                self.unify(at, t1, t2)
+        }
+    }
+
+    occursIn(index: Int, t: Type): Bool {
+        | _, TVariable(_, i) {self.get(i) | Some(type)} => self.occursIn(index, type)
+        | _, TVariable(_, i) => i == index
+        | _, TConstructor(_, _, generics) => generics.any {t => self.occursIn(index, t)}
+    }
+    
+}

package/compiler/Wildcards.ff

@@ -0,0 +1,50 @@
+import Syntax
+
+class Wildcards(mutable seenWildcards : Int)
+
+make(): Wildcards {
+    Wildcards(0)
+}
+
+fail[T](at: Location, message: String): T {
+    panic(message + " " + at.show())
+}
+
+extend self: Wildcards {
+
+    fixWildcards(term: Term): Term {
+        | ELet e => e.ELet(value = self.fixWildcards(e.value), body = self.fixWildcards(e.body))
+        | ESequential e => e.ESequential(before = self.fixWildcards(e.before), after = self.fixWildcards(e.after))
+        | EAssign e => e.EAssign(value = self.fixWildcards(e.value))
+        | EAssignField e => e.EAssignField(record = self.fixWildcards(e.record), value = self.fixWildcards(e.value))
+        | EPipe e => e.EPipe(value = self.fixWildcards(e.value), function = self.fixWildcards(e.function))
+        | ECall e =>
+            e.ECall(
+                target = e.target.{
+                    | DynamicCall call => call.DynamicCall(function = self.fixWildcards(call.function))
+                    | _ => fail(e.at, "Internal error: Static calls not expected in the Wildcards phase")
+                },
+                arguments = e.arguments.map { a => a.Argument(value = self.fixWildcards(a.value)) }
+            )
+        | EList e =>
+            e.EList(items = e.items.map { | Pair(item, spread) =>
+                Pair(self.fixWildcards(item), spread)
+            })
+        | ECopy e =>
+            e.ECopy(
+                record = self.fixWildcards(e.record),
+                arguments = e.arguments.map { a => a.Field(value = self.fixWildcards(a.value)) }
+            )
+        | EVariant e =>
+            e.EVariant(arguments = e.arguments.map { _.map { a =>
+                a.Argument(value = self.fixWildcards(a.value))
+            }})
+        | ERecord e => e.ERecord(fields = e.fields.map { a => a.Field(value = self.fixWildcards(a.value)) })
+        | EField e => e.EField(record = self.fixWildcards(e.record))
+        | EWildcard e =>
+            self.seenWildcards += 1
+            e.EWildcard(index = self.seenWildcards)
+        | _ => term
+    }
+
+}

package/compiler/Workspace.ff

@@ -0,0 +1,88 @@
+import Syntax
+
+data Workspace(
+    rules: List[WorkspaceRule]
+    defaultLocation: String
+    packageDirectory: String
+)
+
+data WorkspaceRule(
+    packageGroup: String
+    packageName: Option[String]
+    location: String
+)
+
+centralLocation = "https://www.firefly-lang.org/packages/"
+
+loadWorkspace(path: Path): Workspace {
+    let packageDirectory = if(path.extension() == ".ff") {path.parent().grab()} else {path}
+    let workspaceFile = packageDirectory.slash(".firefly-workspace")
+    if(workspaceFile.exists()) {
+        parseWorkspaceFile(workspaceFile, packageDirectory)
+    } elseIf {!packageDirectory.parent().isEmpty()} {
+        loadWorkspace(packageDirectory.parent().grab())
+    } else {
+        Workspace([], centralLocation, ".")
+    }
+}
+
+parseWorkspaceFile(path: Path, packageDirectory: Path): Workspace {
+    let text = path.readText()
+    mutable defaultLocation = None
+    let lines = text.split('\n').toList().map {_.replace("\r", "").takeWhile {_ != '#'}}.filter {_.size() != 0}
+    let rules = lines.collect {line =>
+        let columns = line.replace("\t", " ").split(' ').toList().filter {_.size() != 0}
+        defaultLocation.each {_ =>
+            panic("Unexpected rule after the * rule: " + line)
+        }
+        if(columns.size() != 2) {
+            panic("Could not parse workspace rule: " + line)
+        }
+        let package = columns.grab(0)
+        let location = columns.grab(1)
+        let fixedLocation = if(location.endsWith("/")) {location} else {location + "/"}
+        if(package == "*") {
+            defaultLocation = Some(fixedLocation)
+            None
+        } else {
+            let packageParts = package.split(':')
+            if(packageParts.size() != 2) {
+                panic("Could not parse workspace package: " + package)
+            }
+            if(packageParts.grab(0) == "*") {
+                panic("Unexpected wildcard: " + package)
+            }
+            Some(WorkspaceRule(
+                packageGroup = packageParts.grab(0)
+                packageName = if(packageParts.grab(1) != "*") {packageParts.grab(1)}
+                location = fixedLocation
+            ))
+        }
+    }
+    Workspace(rules, defaultLocation.else {centralLocation}, packageDirectory.absolute())
+}
+
+extend self: Workspace {
+
+    findPackageLocation(packagePair: PackagePair, version: Version): String {
+        self.rules.find {rule =>
+            rule.packageGroup == packagePair.group && rule.packageName.all {_ == packagePair.name}
+        }.map {rule =>
+            let prefix = if(rule.packageName == None) {packagePair.name + "/"} else {""}
+            if(rule.location.contains(":")) {
+                rule.location + prefix + tarGzName(packagePair, version)
+            } else {
+                self.packageDirectory + "/" + rule.location + prefix
+            }
+        }.else {
+            self.defaultLocation + packagePair.group + "/" + packagePair.name + "/" +
+            tarGzName(packagePair, version)
+        }
+    }
+
+}
+
+tarGzName(packagePair: PackagePair, version: Version): String {
+    packagePair.group + "_" + packagePair.name + "_" +
+    version.major + "_" + version.minor + "_" + version.patch + ".tar.gz"
+}

package/core/.firefly/package.ff

@@ -0,0 +1,2 @@
+package ff:core:0.0.0
+include "node_modules"

package/core/Any.ff

@@ -0,0 +1,30 @@
+data Any {}
+data AnyTag[T] {}
+
+trait T: HasAnyTag {
+    anyTag(): AnyTag[T]
+}
+
+toAny[T: HasAnyTag](value: T): Any
+    target js sync """
+        const anyTag = ff_core_Any_HasAnyTag$T.anyTag_()
+        return {anyTag: anyTag, value: value_}
+    """
+
+fromAny[T: HasAnyTag](any: Any): Option[T]
+    target js sync """
+        const anyTag = ff_core_Any_HasAnyTag$T.anyTag_()
+        return any_.anyTag === anyTag ? ff_core_Option.Some(any_.value) : ff_core_Option.None()
+    """
+
+extend self[T]: AnyTag[T] {
+    show(): String
+        target js sync """
+            return self_
+        """
+}
+
+internalAnyTag[T](tag: String): AnyTag[T]
+    target js sync """
+        return tag_
+    """