The ISLisp Interpreter @ shibuya.lisp

The ISLisp Interpreter @ shibuya.lisp

ISLisp in JS/Go: Standards-compliant Lisp smaller than Common-Lisp. I introduced ISLisp in the lispmeetup of shibuya.lisp

21cad8b22d4a3b81af209a8ad4caa130?s=128

TANIGUCHI Masaya

August 31, 2017
Tweet

Transcript

  1. THE ISLISP INTERPRETER TANIGUCHI MASAYA @ SHIBUYA.LISP

  2. INTRODUCE TANIGUCHI MASAYA ▸ ਺ֶΛઐ߈͍ͯ͠Δେֶੜ ▸ ܭࢉػ୅਺ॲཧܥʹ͍ͭͯษڧத ▸ CommonLisp, Go,

    JavaScript ͕޷͖ ▸ @ta2gch (Twitter / Github) ▸ ৄ͘͠͸https://ta2gch.github.ioΛ͝ཡ͍ͩ͘͞
  3. AGENDA AGENDA ▸ Introduction to ISLisp and Iris ▸ History

    of the ISLisp ▸ The Features of the ISLisp ▸ The Features of the Iris ▸ The internals of Iris ▸ ILOS - ISLisp Object System ▸ Condition Systems of ISLisp ▸ Iris in the feature
  4. INTRODUCTION TO ISLISP AND IRIS

  5. INTRODUCTION TO ISLISP AND IRIS HISTORY OF ISLISP ▸ CommonLispʹ͍ͭͯޮ཰ͷྑ͞ͱֶशٴͼར༻ͷ༰қ͞

    Λ໨ඪʹ֤ํݴΛࢀߟʹͯ͠։ൃ͞Εͨɻ ▸ ೔ຊͷKernel Languageͱ͍͏Ҋ͕౔୆ʹͳ͍ͬͯΔɻ ▸ ISO/IEC 13816:1997 - Programming Language ISLISP ▸ ISO/IEC 13816:2007 - Programming Language ISLISP ▸ OKI ISLisp Version 0.80 (1999/02/25)
  6. INTRODUCTION TO ISLISP AND IRIS THE FEATURES OF ISLISP ▸

    ILOS - ISLisp Object System͕͋Δ ▸ શͯͷܕ͕ILOSͷࢧ഑Լʹ͋Δ ▸ ੩తൣғΛجຊͱͭͭ͠΋ಈతൣғ͕ѻ͑Δ ▸ ίϯύΫτͳݴޠ࢓༷ (134ϖʔδఔ౓ʣ ▸ ύοέʔδ؅ཧγεςϜ͕ະࡦఆ ▸ PUBLIC DOMAINͷن֨ॻͷ૲Ҋ͕ެ։͞Ε͍ͯΔ ▸ ެࣜαΠτʹن֨४ڌ֬ೝ༻ͷݕূγεςϜ͕͋Δ
  7. INTRODUCTION TO ISLISP AND IRIS DYNAMIC (defun http.request ()
 (format

    
 (standard-output)
 “curl —X ~A ~A”
 (dynamic url)
 (dynamic method))) (dynamic-let
 ((url “islisp.js.org”)
 (method “GET”))
 (http.request)) ▸ΩʔϫʔυҾ਺͕ͳͯ͘΋ɺ
 ہॴಈతม਺Λ࢖ͬͯΩʔϫʔυҾ਺
 ͷΑ͏ͳ͜ͱ͕Ͱ͖Δ ▸CommonLispͱҧͬͯɺେҬม਺ͷΈ
 ಈతม਺ͱ͍͏͜ͱͰ͸ͳ͘ɺͲͪΒ΋
 ྆ํͷൣғΛαϙʔτ͍ͯ͠Δ
  8. ࣗ࡞LISPɺ ࡞Γͨ͘ͳ͍ʁ

  9. INTRODUCTION TO ISLISP AND IRIS IRIS ▸ 2017೥݄̓຤ΑΓ։ൃΛ։࢝ ▸ ISLispΠϯλϓϦλͷGoݴޠ࣮૷(8000ߦҐ)

    ▸ ެࣜαΠτ͸ islisp.js.org ▸ GopherjsʹΑΔJavaScript൛͕͋Δ ▸ ֦ுੑͷߴ͕͞ར఺ͱͳΔͷ༧ఆ ▸ ΫϩεϓϥοτϑΥʔϜ
  10. INTRODUCTION TO ISLISP AND IRIS IRIS PLATFORMS ▸ Darwin ▸

    Linux ▸ FreeBSD ▸ OpenBSD ▸ Windows ▸ NetBSD ▸ Plan9 ▸ Solaris ▸ Android ▸ Dragonfly Goͷαϙʔτ͢ΔϓϥοτϑΥʔϜ Gopherjsͷαϙʔτ͢ΔϓϥοτϑΥʔϜ ▸ Web Browsers ▸ Node.js
  11. THE INTERNALS OF IRIS

  12. THE INTERNALS OF IRIS OVERVIEW IRIS RUNTIME GOPHERJS GO CGO

    GO PLUGIN WEB BROWSERS NATIVE REPL NODE.JS WEB REPL JVM RHINO OS
  13. THE INTERNALS OF IRIS ▸ GoݴޠͷϓϦϛςΟϒܕ(func, int, float, rune) ▸

    ILOSࣗ਎͕༻ҙ͢ΔσʔλΛද͢ߏ଄ମͷܕ ▸ ILOSࣗ਎͕༻ҙ͢ΔΫϥεΛද͢ߏ଄ମͷܕ ▸ interfaceʹΑͬͯந৅Խͯ͠ಉ༷ʹѻ͏ɻ ILOS - ISLISP OBJECT SYSTEM
  14. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM type

    Class interface { Supers() []Class Slots() []Instance Initform(Instance) (Instance, bool) Initarg(Instance) (Instance, bool) Class() Class String() string } type Instance interface { Class() Class String() string } METACLASS 1 METACLASS 2 CLASS 1 CLASS 2 CLASS 3 INSTANCE 1 INSTANCE 3 INSTANCE 4 INSTANCE 2
  15. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM

  16. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Meta

    Class
  17. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Meta

    Class type Instance struct { class ilos.Class supers []ilos.Instance slots map[ilos.Instance]ilos.Instance }
  18. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Meta

    Class
  19. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Meta

    Class type Instance struct { class ilos.Class supers []ilos.Instance slots map[ilos.Instance]ilos.Instance }
  20. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Array

  21. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Array

    type GeneralArrayStar struct { Vector []GeneralArrayStar Scalar ilos.Instance }
  22. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Array

  23. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Array

    type GeneralVector []ilos.Instance
  24. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Array

  25. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Array

    type String []rune
  26. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Character

  27. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Character

    type Integer rune
  28. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Function

  29. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Function

    type Function struct { name ilos.Instance function interface{} }
  30. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Function

  31. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Function

    type method struct { qualifier ilos.Instance classList []ilos.Class function Function } type GenericFunction struct { funcSpec ilos.Instance lambdaList ilos.Instance methodCombination ilos.Instance genericFunctionClass ilos.Class methods []method }
  32. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM List

    and Symbol
  33. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM List

    and Symbol type Cons struct { Car ilos.Instance Cdr ilos.Instance }
  34. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM List

    and Symbol
  35. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM List

    and Symbol type Null struct {}
  36. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM List

    and Symbol
  37. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM List

    and Symbol type Symbol string
  38. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Function

  39. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Function

    type Float float64
  40. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Function

  41. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Function

    type Integer int
  42. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Condition

  43. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Condition

    type Instance struct { class ilos.Class supers []ilos.Instance slots map[ilos.Instance]ilos.Instance }
  44. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Stream

  45. THE INTERNALS OF IRIS ILOS - ISLISP OBJECT SYSTEM Stream

    type Stream struct { Reader io.Reader Writer io.Writer }
  46. THE INTERNALS OF IRIS FUNCTION INSTANCE OF FUNCTION NATIVE FUNCTION

    .APPLY ENVIRONMENT INSTANCE INSTANCE INSTANCE INSTANCE Arguments - Reflection Return Escaping (defun foo (a) a)
  47. THE INTERNALS OF IRIS FUNCTION func Car(e env.Environment, cons ilos.Instance)

    (ilos.Instance, ilos.Instance) { if err := ensure(class.Cons, cons); err != nil { return nil, err } return cons.(*instance.Cons).Car, nil }
  48. THE INTERNALS OF IRIS FUNCTION func Car(e env.Environment, cons ilos.Instance)

    (ilos.Instance, ilos.Instance) { if err := ensure(class.Cons, cons); err != nil { return nil, err } return cons.(*instance.Cons).Car, nil } type Environment struct { // Lexical BlockTag stack TagbodyTag stack Function stack Variable stack // Global Class stack Macro stack Special stack Property map2 GensymID int Constant stack // Dynamic CatchTag stack DynamicVariable stack StandardInput ilos.Instance StandardOutput ilos.Instance ErrorOutput ilos.Instance Handler ilos.Instance }
  49. THE INTERNALS OF IRIS FUNCTION func Car(e env.Environment, cons ilos.Instance)

    (ilos.Instance, ilos.Instance) { if err := ensure(class.Cons, cons); err != nil { return nil, err } return cons.(*instance.Cons).Car, nil }
  50. THE INTERNALS OF IRIS FUNCTION func Car(e env.Environment, cons ilos.Instance)

    (ilos.Instance, ilos.Instance) { if err := ensure(class.Cons, cons); err != nil { return nil, err } return cons.(*instance.Cons).Car, nil } type Instance interface { Class() Class String() string }
  51. THE INTERNALS OF IRIS FUNCTION func Car(e env.Environment, cons ilos.Instance)

    (ilos.Instance, ilos.Instance) { if err := ensure(class.Cons, cons); err != nil { return nil, err } return cons.(*instance.Cons).Car, nil }
  52. THE INTERNALS OF IRIS GENERIC FUNCTION INSTANCE OF GENERIC FUNCTION

    NATIVE FUNCTION .APPLY ENVIRONMENT INSTANCE INSTANCE INSTANCE INSTANCE Arguments Return Escaping NATIVE FUNCTION NATIVE FUNCTION - Selection
 - Ordering
 - Reflection
 - Combination (defgeneric foo (foo bar))
 (defmethod foo :around ((foo A) (bar B)) nil)
  53. THE INTERNALS OF IRIS GENERIC FUNCTION INSTANCE OF GENERIC FUNCTION

    NATIVE FUNCTION .APPLY ENVIRONMENT INSTANCE INSTANCE INSTANCE INSTANCE Arguments Return Escaping NATIVE FUNCTION NATIVE FUNCTION - Selection
 - Ordering
 - Reflection
 - Combination (defgeneric foo (foo bar))
 (defmethod foo :around ((foo A) (bar B)) nil)
  54. THE INTERNALS OF IRIS GENERIC FUNCTION 1. Simple Combination (nil)

    ▸ ༏ઌॱҐΛܾఆ ▸ ࠷༏ઌؔ਺ͷ໭Γ஋͕แׅؔ਺ͷ໭Γ஋ͱͳΔ ▸ CALL-NEXT-METHODͰ࣍఺༏ઌؔ਺Λݺͼग़ͤΔ 2. Standard Combination (نఆ) ▸ ༏ઌॱҐΛܾఆ ▸ ࠷༏ઌؔ਺ͷ໭Γ஋͕แׅؔ਺ͷ໭Γ஋ͱͳΔ ▸ :around → (:before) → ࢦఆແ͠ →(:after)ɹͷॱͰ࣮ߦ ▸ :aroundͱࢦఆແ͠ͷؔ਺͸CALL-NEXT-METHODͰ࣍఺༏ઌؔ਺Λݺͼग़ͤΔ
  55. THE INTERNALS OF IRIS GENERIC FUNCTION e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) }

    return methods[0].function.Apply(e, arguments ...) //Call first of method } // if f.methodCombination == NewSymbol("STANDARD") { test := func(i int) bool { return methods[i].qualifier == around } width := len(methods) if index := sort.Search(width, test); index < width { // if has :around methods // This callNextMethod is called in :around methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth for index, method := range methods[:int(depth.(Integer))+1] { if method.qualifier == around { // If have :around method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil || methods[index+i+1].qualifier == around } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) // Call next method } } // If has no :around method then, // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } // Do the first of primary methods // this callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) // Get index of next mehotd e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) // Call next method } // callNextMethod ends here index := 0 // index of the first primary method { // index != 0 is always true because this function has :around methods width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } // Do primary methods ret, err := methods[index].function.Apply(e, arguments ...) if err != nil { return nil, err } // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) } } { // Function has no :around methods // This callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 index = sort.Search(width, test) } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) } // callNextMethod ends here // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } index := 0 // index of the first primary method { test := func(i int) bool { return methods[i].qualifier == nil } width := len(methods) index := sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) if index == len(methods) { return nil, NewUndefinedFunction(f.funcSpec) } } e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functions test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } ret, err := methods[index].function.Apply(e, arguments ...) // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this // file, You can obtain one at http: //mozilla.org/MPL/2.0/. package instance import ( "fmt" "reflect" "sort" "github.com/ta2gch/iris/runtime/env" "github.com/ta2gch/iris/runtime/ilos" ) type Applicable interface { Apply(env.Environment, ...ilos.Instance) (ilos.Instance, ilos.Instance) } type Function struct { name ilos.Instance function interface{} } func NewFunction(name ilos.Instance, function interface{}) ilos.Instance { return Function{name, function} } func (Function) Class() ilos.Class { return FunctionClass } func (f Function) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f Function) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { fv := reflect.ValueOf(f.function) ft := reflect.TypeOf(f.function) argv := []reflect.Value{reflect.ValueOf(e)} for _, cadr := range arguments { argv = append(argv, reflect.ValueOf(cadr)) } if ft.NumIn() != len(argv) && (!ft.IsVariadic() || ft.NumIn()-2 >= len(argv)) { return nil, NewArityError() } rets := fv.Call(argv) a, _ := rets[0].Interface().(ilos.Instance) b, _ := rets[1].Interface().(ilos.Instance) return a, b } type method struct { qualifier ilos.Instance classList []ilos.Class function Function } type GenericFunction struct { funcSpec ilos.Instance lambdaList ilos.Instance methodCombination ilos.Instance genericFunctionClass ilos.Class methods []method } func NewGenericFunction(funcSpec, lambdaList, methodCombination ilos.Instance, genericFunctionClass ilos.Class) ilos.Instance { return &GenericFunction{funcSpec, lambdaList, methodCombination, genericFunctionClass, []method{}} } func (f *GenericFunction) AddMethod(qualifier, lambdaList ilos.Instance, classList []ilos.Class, function ilos.Instance) bool { if f.lambdaList.(List).Length() != lambdaList.(List).Length() { return false } for i, param := range f.lambdaList.(List).Slice() { if param == NewSymbol(":REST") || param == NewSymbol("&REST") { if lambdaList.(List).Nth(i) != NewSymbol(":REST") && lambdaList.(List).Nth(i) != NewSymbol("&REST") { return false } } } for i := range f.methods { if f.methods[i].qualifier == qualifier && reflect.DeepEqual(f.methods[i].classList, classList) { f.methods[i].function = function.(Function) return true } } f.methods = append(f.methods, method{qualifier, classList, function.(Function)}) return true } func (f *GenericFunction) Class() ilos.Class { return f.genericFunctionClass } func (f *GenericFunction) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f *GenericFunction) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { parameters := f.lambdaList.(List).Slice() variadic := false { test := func(i int) bool { return parameters[i] == NewSymbol(":REST") || parameters[i] == NewSymbol("&REST") } if sort.Search(len(parameters), test) < len(parameters) { variadic = true } } if (variadic && len(parameters)-2 > len(arguments)) || (!variadic && len(parameters) != len(arguments)) { return nil, NewArityError() } methods := []method{} for _, method := range f.methods { matched := true for i, c := range method.classList { if !ilos.InstanceOf(c, arguments[i]) { matched = false break } } if matched { methods = append(methods, method) } } before := NewSymbol(":BEFORE") around := NewSymbol(":AROUND") after := NewSymbol(":AFTER") sort.Slice(methods, func(a, b int) bool { for i := range methods[a].classList { if ilos.SubclassOf(methods[a].classList[i], methods[b].classList[i]) { return false } if ilos.SubclassOf(methods[b].classList[i], methods[a].classList[i]) { return true } } t := map[ilos.Instance]int{around: 4, before: 3, nil: 2, after: 1} return t[methods[a].qualifier] > t[methods[b].qualifier] }) nextMethodPisNil := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return Nil, nil }) nextMethodPisT := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return T, nil }) if f.methodCombination == NewSymbol("NIL") { var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) // To Recursive callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { // CALL-NEXT-METHOD depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) + 1 // Get index of next method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if int(depth.(Integer))+1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) } return methods[index].function.Apply(e, arguments ...) // Call next method } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(0)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if 1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT))
  56. THE INTERNALS OF IRIS GENERIC FUNCTION e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) }

    return methods[0].function.Apply(e, arguments ...) //Call first of method } // if f.methodCombination == NewSymbol("STANDARD") { test := func(i int) bool { return methods[i].qualifier == around } width := len(methods) if index := sort.Search(width, test); index < width { // if has :around methods // This callNextMethod is called in :around methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth for index, method := range methods[:int(depth.(Integer))+1] { if method.qualifier == around { // If have :around method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil || methods[index+i+1].qualifier == around } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) // Call next method } } // If has no :around method then, // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } // Do the first of primary methods // this callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) // Get index of next mehotd e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) // Call next method } // callNextMethod ends here index := 0 // index of the first primary method { // index != 0 is always true because this function has :around methods width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } // Do primary methods ret, err := methods[index].function.Apply(e, arguments ...) if err != nil { return nil, err } // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) } } { // Function has no :around methods // This callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 index = sort.Search(width, test) } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) } // callNextMethod ends here // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } index := 0 // index of the first primary method { test := func(i int) bool { return methods[i].qualifier == nil } width := len(methods) index := sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) if index == len(methods) { return nil, NewUndefinedFunction(f.funcSpec) } } e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functions test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } ret, err := methods[index].function.Apply(e, arguments ...) // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this // file, You can obtain one at http: //mozilla.org/MPL/2.0/. package instance import ( "fmt" "reflect" "sort" "github.com/ta2gch/iris/runtime/env" "github.com/ta2gch/iris/runtime/ilos" ) type Applicable interface { Apply(env.Environment, ...ilos.Instance) (ilos.Instance, ilos.Instance) } type Function struct { name ilos.Instance function interface{} } func NewFunction(name ilos.Instance, function interface{}) ilos.Instance { return Function{name, function} } func (Function) Class() ilos.Class { return FunctionClass } func (f Function) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f Function) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { fv := reflect.ValueOf(f.function) ft := reflect.TypeOf(f.function) argv := []reflect.Value{reflect.ValueOf(e)} for _, cadr := range arguments { argv = append(argv, reflect.ValueOf(cadr)) } if ft.NumIn() != len(argv) && (!ft.IsVariadic() || ft.NumIn()-2 >= len(argv)) { return nil, NewArityError() } rets := fv.Call(argv) a, _ := rets[0].Interface().(ilos.Instance) b, _ := rets[1].Interface().(ilos.Instance) return a, b } type method struct { qualifier ilos.Instance classList []ilos.Class function Function } type GenericFunction struct { funcSpec ilos.Instance lambdaList ilos.Instance methodCombination ilos.Instance genericFunctionClass ilos.Class methods []method } func NewGenericFunction(funcSpec, lambdaList, methodCombination ilos.Instance, genericFunctionClass ilos.Class) ilos.Instance { return &GenericFunction{funcSpec, lambdaList, methodCombination, genericFunctionClass, []method{}} } func (f *GenericFunction) AddMethod(qualifier, lambdaList ilos.Instance, classList []ilos.Class, function ilos.Instance) bool { if f.lambdaList.(List).Length() != lambdaList.(List).Length() { return false } for i, param := range f.lambdaList.(List).Slice() { if param == NewSymbol(":REST") || param == NewSymbol("&REST") { if lambdaList.(List).Nth(i) != NewSymbol(":REST") && lambdaList.(List).Nth(i) != NewSymbol("&REST") { return false } } } for i := range f.methods { if f.methods[i].qualifier == qualifier && reflect.DeepEqual(f.methods[i].classList, classList) { f.methods[i].function = function.(Function) return true } } f.methods = append(f.methods, method{qualifier, classList, function.(Function)}) return true } func (f *GenericFunction) Class() ilos.Class { return f.genericFunctionClass } func (f *GenericFunction) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f *GenericFunction) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { parameters := f.lambdaList.(List).Slice() variadic := false { test := func(i int) bool { return parameters[i] == NewSymbol(":REST") || parameters[i] == NewSymbol("&REST") } if sort.Search(len(parameters), test) < len(parameters) { variadic = true } } if (variadic && len(parameters)-2 > len(arguments)) || (!variadic && len(parameters) != len(arguments)) { return nil, NewArityError() } methods := []method{} for _, method := range f.methods { matched := true for i, c := range method.classList { if !ilos.InstanceOf(c, arguments[i]) { matched = false break } } if matched { methods = append(methods, method) } } before := NewSymbol(":BEFORE") around := NewSymbol(":AROUND") after := NewSymbol(":AFTER") sort.Slice(methods, func(a, b int) bool { for i := range methods[a].classList { if ilos.SubclassOf(methods[a].classList[i], methods[b].classList[i]) { return false } if ilos.SubclassOf(methods[b].classList[i], methods[a].classList[i]) { return true } } t := map[ilos.Instance]int{around: 4, before: 3, nil: 2, after: 1} return t[methods[a].qualifier] > t[methods[b].qualifier] }) nextMethodPisNil := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return Nil, nil }) nextMethodPisT := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return T, nil }) if f.methodCombination == NewSymbol("NIL") { var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) // To Recursive callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { // CALL-NEXT-METHOD depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) + 1 // Get index of next method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if int(depth.(Integer))+1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) } return methods[index].function.Apply(e, arguments ...) // Call next method } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(0)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if 1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT))
  57. THE INTERNALS OF IRIS GENERIC FUNCTION e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) }

    return methods[0].function.Apply(e, arguments ...) //Call first of method } // if f.methodCombination == NewSymbol("STANDARD") { test := func(i int) bool { return methods[i].qualifier == around } width := len(methods) if index := sort.Search(width, test); index < width { // if has :around methods // This callNextMethod is called in :around methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth for index, method := range methods[:int(depth.(Integer))+1] { if method.qualifier == around { // If have :around method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil || methods[index+i+1].qualifier == around } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) // Call next method } } // If has no :around method then, // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } // Do the first of primary methods // this callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) // Get index of next mehotd e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) // Call next method } // callNextMethod ends here index := 0 // index of the first primary method { // index != 0 is always true because this function has :around methods width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } // Do primary methods ret, err := methods[index].function.Apply(e, arguments ...) if err != nil { return nil, err } // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) } } { // Function has no :around methods // This callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 index = sort.Search(width, test) } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) } // callNextMethod ends here // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } index := 0 // index of the first primary method { test := func(i int) bool { return methods[i].qualifier == nil } width := len(methods) index := sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) if index == len(methods) { return nil, NewUndefinedFunction(f.funcSpec) } } e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functions test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } ret, err := methods[index].function.Apply(e, arguments ...) // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this // file, You can obtain one at http: //mozilla.org/MPL/2.0/. package instance import ( "fmt" "reflect" "sort" "github.com/ta2gch/iris/runtime/env" "github.com/ta2gch/iris/runtime/ilos" ) type Applicable interface { Apply(env.Environment, ...ilos.Instance) (ilos.Instance, ilos.Instance) } type Function struct { name ilos.Instance function interface{} } func NewFunction(name ilos.Instance, function interface{}) ilos.Instance { return Function{name, function} } func (Function) Class() ilos.Class { return FunctionClass } func (f Function) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f Function) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { fv := reflect.ValueOf(f.function) ft := reflect.TypeOf(f.function) argv := []reflect.Value{reflect.ValueOf(e)} for _, cadr := range arguments { argv = append(argv, reflect.ValueOf(cadr)) } if ft.NumIn() != len(argv) && (!ft.IsVariadic() || ft.NumIn()-2 >= len(argv)) { return nil, NewArityError() } rets := fv.Call(argv) a, _ := rets[0].Interface().(ilos.Instance) b, _ := rets[1].Interface().(ilos.Instance) return a, b } type method struct { qualifier ilos.Instance classList []ilos.Class function Function } type GenericFunction struct { funcSpec ilos.Instance lambdaList ilos.Instance methodCombination ilos.Instance genericFunctionClass ilos.Class methods []method } func NewGenericFunction(funcSpec, lambdaList, methodCombination ilos.Instance, genericFunctionClass ilos.Class) ilos.Instance { return &GenericFunction{funcSpec, lambdaList, methodCombination, genericFunctionClass, []method{}} } func (f *GenericFunction) AddMethod(qualifier, lambdaList ilos.Instance, classList []ilos.Class, function ilos.Instance) bool { if f.lambdaList.(List).Length() != lambdaList.(List).Length() { return false } for i, param := range f.lambdaList.(List).Slice() { if param == NewSymbol(":REST") || param == NewSymbol("&REST") { if lambdaList.(List).Nth(i) != NewSymbol(":REST") && lambdaList.(List).Nth(i) != NewSymbol("&REST") { return false } } } for i := range f.methods { if f.methods[i].qualifier == qualifier && reflect.DeepEqual(f.methods[i].classList, classList) { f.methods[i].function = function.(Function) return true } } f.methods = append(f.methods, method{qualifier, classList, function.(Function)}) return true } func (f *GenericFunction) Class() ilos.Class { return f.genericFunctionClass } func (f *GenericFunction) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f *GenericFunction) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { parameters := f.lambdaList.(List).Slice() variadic := false { test := func(i int) bool { return parameters[i] == NewSymbol(":REST") || parameters[i] == NewSymbol("&REST") } if sort.Search(len(parameters), test) < len(parameters) { variadic = true } } if (variadic && len(parameters)-2 > len(arguments)) || (!variadic && len(parameters) != len(arguments)) { return nil, NewArityError() } methods := []method{} for _, method := range f.methods { matched := true for i, c := range method.classList { if !ilos.InstanceOf(c, arguments[i]) { matched = false break } } if matched { methods = append(methods, method) } } before := NewSymbol(":BEFORE") around := NewSymbol(":AROUND") after := NewSymbol(":AFTER") sort.Slice(methods, func(a, b int) bool { for i := range methods[a].classList { if ilos.SubclassOf(methods[a].classList[i], methods[b].classList[i]) { return false } if ilos.SubclassOf(methods[b].classList[i], methods[a].classList[i]) { return true } } t := map[ilos.Instance]int{around: 4, before: 3, nil: 2, after: 1} return t[methods[a].qualifier] > t[methods[b].qualifier] }) nextMethodPisNil := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return Nil, nil }) nextMethodPisT := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return T, nil }) if f.methodCombination == NewSymbol("NIL") { var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) // To Recursive callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { // CALL-NEXT-METHOD depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) + 1 // Get index of next method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if int(depth.(Integer))+1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) } return methods[index].function.Apply(e, arguments ...) // Call next method } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(0)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if 1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) ௨ৗͷؔ਺ͷؔ਺ݺͼग़͠ͷ࣮૷ ϦϑϨΫγϣϯΛ࢖ͬͯωΠςΟϒؔ਺Λ ݺͼग़͢ɻ
  58. THE INTERNALS OF IRIS GENERIC FUNCTION e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) }

    return methods[0].function.Apply(e, arguments ...) //Call first of method } // if f.methodCombination == NewSymbol("STANDARD") { test := func(i int) bool { return methods[i].qualifier == around } width := len(methods) if index := sort.Search(width, test); index < width { // if has :around methods // This callNextMethod is called in :around methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth for index, method := range methods[:int(depth.(Integer))+1] { if method.qualifier == around { // If have :around method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil || methods[index+i+1].qualifier == around } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) // Call next method } } // If has no :around method then, // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } // Do the first of primary methods // this callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) // Get index of next mehotd e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) // Call next method } // callNextMethod ends here index := 0 // index of the first primary method { // index != 0 is always true because this function has :around methods width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } // Do primary methods ret, err := methods[index].function.Apply(e, arguments ...) if err != nil { return nil, err } // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) } } { // Function has no :around methods // This callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 index = sort.Search(width, test) } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) } // callNextMethod ends here // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } index := 0 // index of the first primary method { test := func(i int) bool { return methods[i].qualifier == nil } width := len(methods) index := sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) if index == len(methods) { return nil, NewUndefinedFunction(f.funcSpec) } } e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functions test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } ret, err := methods[index].function.Apply(e, arguments ...) // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this // file, You can obtain one at http: //mozilla.org/MPL/2.0/. package instance import ( "fmt" "reflect" "sort" "github.com/ta2gch/iris/runtime/env" "github.com/ta2gch/iris/runtime/ilos" ) type Applicable interface { Apply(env.Environment, ...ilos.Instance) (ilos.Instance, ilos.Instance) } type Function struct { name ilos.Instance function interface{} } func NewFunction(name ilos.Instance, function interface{}) ilos.Instance { return Function{name, function} } func (Function) Class() ilos.Class { return FunctionClass } func (f Function) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f Function) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { fv := reflect.ValueOf(f.function) ft := reflect.TypeOf(f.function) argv := []reflect.Value{reflect.ValueOf(e)} for _, cadr := range arguments { argv = append(argv, reflect.ValueOf(cadr)) } if ft.NumIn() != len(argv) && (!ft.IsVariadic() || ft.NumIn()-2 >= len(argv)) { return nil, NewArityError() } rets := fv.Call(argv) a, _ := rets[0].Interface().(ilos.Instance) b, _ := rets[1].Interface().(ilos.Instance) return a, b } type method struct { qualifier ilos.Instance classList []ilos.Class function Function } type GenericFunction struct { funcSpec ilos.Instance lambdaList ilos.Instance methodCombination ilos.Instance genericFunctionClass ilos.Class methods []method } func NewGenericFunction(funcSpec, lambdaList, methodCombination ilos.Instance, genericFunctionClass ilos.Class) ilos.Instance { return &GenericFunction{funcSpec, lambdaList, methodCombination, genericFunctionClass, []method{}} } func (f *GenericFunction) AddMethod(qualifier, lambdaList ilos.Instance, classList []ilos.Class, function ilos.Instance) bool { if f.lambdaList.(List).Length() != lambdaList.(List).Length() { return false } for i, param := range f.lambdaList.(List).Slice() { if param == NewSymbol(":REST") || param == NewSymbol("&REST") { if lambdaList.(List).Nth(i) != NewSymbol(":REST") && lambdaList.(List).Nth(i) != NewSymbol("&REST") { return false } } } for i := range f.methods { if f.methods[i].qualifier == qualifier && reflect.DeepEqual(f.methods[i].classList, classList) { f.methods[i].function = function.(Function) return true } } f.methods = append(f.methods, method{qualifier, classList, function.(Function)}) return true } func (f *GenericFunction) Class() ilos.Class { return f.genericFunctionClass } func (f *GenericFunction) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f *GenericFunction) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { parameters := f.lambdaList.(List).Slice() variadic := false { test := func(i int) bool { return parameters[i] == NewSymbol(":REST") || parameters[i] == NewSymbol("&REST") } if sort.Search(len(parameters), test) < len(parameters) { variadic = true } } if (variadic && len(parameters)-2 > len(arguments)) || (!variadic && len(parameters) != len(arguments)) { return nil, NewArityError() } methods := []method{} for _, method := range f.methods { matched := true for i, c := range method.classList { if !ilos.InstanceOf(c, arguments[i]) { matched = false break } } if matched { methods = append(methods, method) } } before := NewSymbol(":BEFORE") around := NewSymbol(":AROUND") after := NewSymbol(":AFTER") sort.Slice(methods, func(a, b int) bool { for i := range methods[a].classList { if ilos.SubclassOf(methods[a].classList[i], methods[b].classList[i]) { return false } if ilos.SubclassOf(methods[b].classList[i], methods[a].classList[i]) { return true } } t := map[ilos.Instance]int{around: 4, before: 3, nil: 2, after: 1} return t[methods[a].qualifier] > t[methods[b].qualifier] }) nextMethodPisNil := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return Nil, nil }) nextMethodPisT := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return T, nil }) if f.methodCombination == NewSymbol("NIL") { var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) // To Recursive callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { // CALL-NEXT-METHOD depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) + 1 // Get index of next method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if int(depth.(Integer))+1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) } return methods[index].function.Apply(e, arguments ...) // Call next method } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(0)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if 1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) ௨ৗͷؔ਺ͷؔ਺ݺͼग़͠ͷ࣮૷ ϦϑϨΫγϣϯΛ࢖ͬͯωΠςΟϒؔ਺Λ ݺͼग़͢ɻ
  59. THE INTERNALS OF IRIS GENERIC FUNCTION e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) }

    return methods[0].function.Apply(e, arguments ...) //Call first of method } // if f.methodCombination == NewSymbol("STANDARD") { test := func(i int) bool { return methods[i].qualifier == around } width := len(methods) if index := sort.Search(width, test); index < width { // if has :around methods // This callNextMethod is called in :around methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth for index, method := range methods[:int(depth.(Integer))+1] { if method.qualifier == around { // If have :around method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil || methods[index+i+1].qualifier == around } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) // Call next method } } // If has no :around method then, // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } // Do the first of primary methods // this callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) // Get index of next mehotd e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) // Call next method } // callNextMethod ends here index := 0 // index of the first primary method { // index != 0 is always true because this function has :around methods width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } // Do primary methods ret, err := methods[index].function.Apply(e, arguments ...) if err != nil { return nil, err } // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) } } { // Function has no :around methods // This callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 index = sort.Search(width, test) } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) } // callNextMethod ends here // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } index := 0 // index of the first primary method { test := func(i int) bool { return methods[i].qualifier == nil } width := len(methods) index := sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) if index == len(methods) { return nil, NewUndefinedFunction(f.funcSpec) } } e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functions test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } ret, err := methods[index].function.Apply(e, arguments ...) // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this // file, You can obtain one at http: //mozilla.org/MPL/2.0/. package instance import ( "fmt" "reflect" "sort" "github.com/ta2gch/iris/runtime/env" "github.com/ta2gch/iris/runtime/ilos" ) type Applicable interface { Apply(env.Environment, ...ilos.Instance) (ilos.Instance, ilos.Instance) } type Function struct { name ilos.Instance function interface{} } func NewFunction(name ilos.Instance, function interface{}) ilos.Instance { return Function{name, function} } func (Function) Class() ilos.Class { return FunctionClass } func (f Function) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f Function) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { fv := reflect.ValueOf(f.function) ft := reflect.TypeOf(f.function) argv := []reflect.Value{reflect.ValueOf(e)} for _, cadr := range arguments { argv = append(argv, reflect.ValueOf(cadr)) } if ft.NumIn() != len(argv) && (!ft.IsVariadic() || ft.NumIn()-2 >= len(argv)) { return nil, NewArityError() } rets := fv.Call(argv) a, _ := rets[0].Interface().(ilos.Instance) b, _ := rets[1].Interface().(ilos.Instance) return a, b } type method struct { qualifier ilos.Instance classList []ilos.Class function Function } type GenericFunction struct { funcSpec ilos.Instance lambdaList ilos.Instance methodCombination ilos.Instance genericFunctionClass ilos.Class methods []method } func NewGenericFunction(funcSpec, lambdaList, methodCombination ilos.Instance, genericFunctionClass ilos.Class) ilos.Instance { return &GenericFunction{funcSpec, lambdaList, methodCombination, genericFunctionClass, []method{}} } func (f *GenericFunction) AddMethod(qualifier, lambdaList ilos.Instance, classList []ilos.Class, function ilos.Instance) bool { if f.lambdaList.(List).Length() != lambdaList.(List).Length() { return false } for i, param := range f.lambdaList.(List).Slice() { if param == NewSymbol(":REST") || param == NewSymbol("&REST") { if lambdaList.(List).Nth(i) != NewSymbol(":REST") && lambdaList.(List).Nth(i) != NewSymbol("&REST") { return false } } } for i := range f.methods { if f.methods[i].qualifier == qualifier && reflect.DeepEqual(f.methods[i].classList, classList) { f.methods[i].function = function.(Function) return true } } f.methods = append(f.methods, method{qualifier, classList, function.(Function)}) return true } func (f *GenericFunction) Class() ilos.Class { return f.genericFunctionClass } func (f *GenericFunction) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f *GenericFunction) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { parameters := f.lambdaList.(List).Slice() variadic := false { test := func(i int) bool { return parameters[i] == NewSymbol(":REST") || parameters[i] == NewSymbol("&REST") } if sort.Search(len(parameters), test) < len(parameters) { variadic = true } } if (variadic && len(parameters)-2 > len(arguments)) || (!variadic && len(parameters) != len(arguments)) { return nil, NewArityError() } methods := []method{} for _, method := range f.methods { matched := true for i, c := range method.classList { if !ilos.InstanceOf(c, arguments[i]) { matched = false break } } if matched { methods = append(methods, method) } } before := NewSymbol(":BEFORE") around := NewSymbol(":AROUND") after := NewSymbol(":AFTER") sort.Slice(methods, func(a, b int) bool { for i := range methods[a].classList { if ilos.SubclassOf(methods[a].classList[i], methods[b].classList[i]) { return false } if ilos.SubclassOf(methods[b].classList[i], methods[a].classList[i]) { return true } } t := map[ilos.Instance]int{around: 4, before: 3, nil: 2, after: 1} return t[methods[a].qualifier] > t[methods[b].qualifier] }) nextMethodPisNil := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return Nil, nil }) nextMethodPisT := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return T, nil }) if f.methodCombination == NewSymbol("NIL") { var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) // To Recursive callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { // CALL-NEXT-METHOD depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) + 1 // Get index of next method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if int(depth.(Integer))+1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) } return methods[index].function.Apply(e, arguments ...) // Call next method } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(0)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if 1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT))
  60. THE INTERNALS OF IRIS GENERIC FUNCTION e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) }

    return methods[0].function.Apply(e, arguments ...) //Call first of method } // if f.methodCombination == NewSymbol("STANDARD") { test := func(i int) bool { return methods[i].qualifier == around } width := len(methods) if index := sort.Search(width, test); index < width { // if has :around methods // This callNextMethod is called in :around methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth for index, method := range methods[:int(depth.(Integer))+1] { if method.qualifier == around { // If have :around method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil || methods[index+i+1].qualifier == around } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) // Call next method } } // If has no :around method then, // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } // Do the first of primary methods // this callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) // Get index of next mehotd e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) // Call next method } // callNextMethod ends here index := 0 // index of the first primary method { // index != 0 is always true because this function has :around methods width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } // Do primary methods ret, err := methods[index].function.Apply(e, arguments ...) if err != nil { return nil, err } // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) } } { // Function has no :around methods // This callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 index = sort.Search(width, test) } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) } // callNextMethod ends here // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } index := 0 // index of the first primary method { test := func(i int) bool { return methods[i].qualifier == nil } width := len(methods) index := sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) if index == len(methods) { return nil, NewUndefinedFunction(f.funcSpec) } } e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functions test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } ret, err := methods[index].function.Apply(e, arguments ...) // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this // file, You can obtain one at http: //mozilla.org/MPL/2.0/. package instance import ( "fmt" "reflect" "sort" "github.com/ta2gch/iris/runtime/env" "github.com/ta2gch/iris/runtime/ilos" ) type Applicable interface { Apply(env.Environment, ...ilos.Instance) (ilos.Instance, ilos.Instance) } type Function struct { name ilos.Instance function interface{} } func NewFunction(name ilos.Instance, function interface{}) ilos.Instance { return Function{name, function} } func (Function) Class() ilos.Class { return FunctionClass } func (f Function) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f Function) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { fv := reflect.ValueOf(f.function) ft := reflect.TypeOf(f.function) argv := []reflect.Value{reflect.ValueOf(e)} for _, cadr := range arguments { argv = append(argv, reflect.ValueOf(cadr)) } if ft.NumIn() != len(argv) && (!ft.IsVariadic() || ft.NumIn()-2 >= len(argv)) { return nil, NewArityError() } rets := fv.Call(argv) a, _ := rets[0].Interface().(ilos.Instance) b, _ := rets[1].Interface().(ilos.Instance) return a, b } type method struct { qualifier ilos.Instance classList []ilos.Class function Function } type GenericFunction struct { funcSpec ilos.Instance lambdaList ilos.Instance methodCombination ilos.Instance genericFunctionClass ilos.Class methods []method } func NewGenericFunction(funcSpec, lambdaList, methodCombination ilos.Instance, genericFunctionClass ilos.Class) ilos.Instance { return &GenericFunction{funcSpec, lambdaList, methodCombination, genericFunctionClass, []method{}} } func (f *GenericFunction) AddMethod(qualifier, lambdaList ilos.Instance, classList []ilos.Class, function ilos.Instance) bool { if f.lambdaList.(List).Length() != lambdaList.(List).Length() { return false } for i, param := range f.lambdaList.(List).Slice() { if param == NewSymbol(":REST") || param == NewSymbol("&REST") { if lambdaList.(List).Nth(i) != NewSymbol(":REST") && lambdaList.(List).Nth(i) != NewSymbol("&REST") { return false } } } for i := range f.methods { if f.methods[i].qualifier == qualifier && reflect.DeepEqual(f.methods[i].classList, classList) { f.methods[i].function = function.(Function) return true } } f.methods = append(f.methods, method{qualifier, classList, function.(Function)}) return true } func (f *GenericFunction) Class() ilos.Class { return f.genericFunctionClass } func (f *GenericFunction) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f *GenericFunction) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { parameters := f.lambdaList.(List).Slice() variadic := false { test := func(i int) bool { return parameters[i] == NewSymbol(":REST") || parameters[i] == NewSymbol("&REST") } if sort.Search(len(parameters), test) < len(parameters) { variadic = true } } if (variadic && len(parameters)-2 > len(arguments)) || (!variadic && len(parameters) != len(arguments)) { return nil, NewArityError() } methods := []method{} for _, method := range f.methods { matched := true for i, c := range method.classList { if !ilos.InstanceOf(c, arguments[i]) { matched = false break } } if matched { methods = append(methods, method) } } before := NewSymbol(":BEFORE") around := NewSymbol(":AROUND") after := NewSymbol(":AFTER") sort.Slice(methods, func(a, b int) bool { for i := range methods[a].classList { if ilos.SubclassOf(methods[a].classList[i], methods[b].classList[i]) { return false } if ilos.SubclassOf(methods[b].classList[i], methods[a].classList[i]) { return true } } t := map[ilos.Instance]int{around: 4, before: 3, nil: 2, after: 1} return t[methods[a].qualifier] > t[methods[b].qualifier] }) nextMethodPisNil := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return Nil, nil }) nextMethodPisT := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return T, nil }) if f.methodCombination == NewSymbol("NIL") { var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) // To Recursive callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { // CALL-NEXT-METHOD depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) + 1 // Get index of next method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if int(depth.(Integer))+1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) } return methods[index].function.Apply(e, arguments ...) // Call next method } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(0)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if 1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT))
  61. THE INTERNALS OF IRIS GENERIC FUNCTION e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) }

    return methods[0].function.Apply(e, arguments ...) //Call first of method } // if f.methodCombination == NewSymbol("STANDARD") { test := func(i int) bool { return methods[i].qualifier == around } width := len(methods) if index := sort.Search(width, test); index < width { // if has :around methods // This callNextMethod is called in :around methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth for index, method := range methods[:int(depth.(Integer))+1] { if method.qualifier == around { // If have :around method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil || methods[index+i+1].qualifier == around } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) // Call next method } } // If has no :around method then, // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } // Do the first of primary methods // this callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) // Get index of next mehotd e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) // Call next method } // callNextMethod ends here index := 0 // index of the first primary method { // index != 0 is always true because this function has :around methods width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } // Do primary methods ret, err := methods[index].function.Apply(e, arguments ...) if err != nil { return nil, err } // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) } } { // Function has no :around methods // This callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 index = sort.Search(width, test) } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) } // callNextMethod ends here // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } index := 0 // index of the first primary method { test := func(i int) bool { return methods[i].qualifier == nil } width := len(methods) index := sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) if index == len(methods) { return nil, NewUndefinedFunction(f.funcSpec) } } e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functions test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } ret, err := methods[index].function.Apply(e, arguments ...) // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this // file, You can obtain one at http: //mozilla.org/MPL/2.0/. package instance import ( "fmt" "reflect" "sort" "github.com/ta2gch/iris/runtime/env" "github.com/ta2gch/iris/runtime/ilos" ) type Applicable interface { Apply(env.Environment, ...ilos.Instance) (ilos.Instance, ilos.Instance) } type Function struct { name ilos.Instance function interface{} } func NewFunction(name ilos.Instance, function interface{}) ilos.Instance { return Function{name, function} } func (Function) Class() ilos.Class { return FunctionClass } func (f Function) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f Function) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { fv := reflect.ValueOf(f.function) ft := reflect.TypeOf(f.function) argv := []reflect.Value{reflect.ValueOf(e)} for _, cadr := range arguments { argv = append(argv, reflect.ValueOf(cadr)) } if ft.NumIn() != len(argv) && (!ft.IsVariadic() || ft.NumIn()-2 >= len(argv)) { return nil, NewArityError() } rets := fv.Call(argv) a, _ := rets[0].Interface().(ilos.Instance) b, _ := rets[1].Interface().(ilos.Instance) return a, b } type method struct { qualifier ilos.Instance classList []ilos.Class function Function } type GenericFunction struct { funcSpec ilos.Instance lambdaList ilos.Instance methodCombination ilos.Instance genericFunctionClass ilos.Class methods []method } func NewGenericFunction(funcSpec, lambdaList, methodCombination ilos.Instance, genericFunctionClass ilos.Class) ilos.Instance { return &GenericFunction{funcSpec, lambdaList, methodCombination, genericFunctionClass, []method{}} } func (f *GenericFunction) AddMethod(qualifier, lambdaList ilos.Instance, classList []ilos.Class, function ilos.Instance) bool { if f.lambdaList.(List).Length() != lambdaList.(List).Length() { return false } for i, param := range f.lambdaList.(List).Slice() { if param == NewSymbol(":REST") || param == NewSymbol("&REST") { if lambdaList.(List).Nth(i) != NewSymbol(":REST") && lambdaList.(List).Nth(i) != NewSymbol("&REST") { return false } } } for i := range f.methods { if f.methods[i].qualifier == qualifier && reflect.DeepEqual(f.methods[i].classList, classList) { f.methods[i].function = function.(Function) return true } } f.methods = append(f.methods, method{qualifier, classList, function.(Function)}) return true } func (f *GenericFunction) Class() ilos.Class { return f.genericFunctionClass } func (f *GenericFunction) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f *GenericFunction) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { parameters := f.lambdaList.(List).Slice() variadic := false { test := func(i int) bool { return parameters[i] == NewSymbol(":REST") || parameters[i] == NewSymbol("&REST") } if sort.Search(len(parameters), test) < len(parameters) { variadic = true } } if (variadic && len(parameters)-2 > len(arguments)) || (!variadic && len(parameters) != len(arguments)) { return nil, NewArityError() } methods := []method{} for _, method := range f.methods { matched := true for i, c := range method.classList { if !ilos.InstanceOf(c, arguments[i]) { matched = false break } } if matched { methods = append(methods, method) } } before := NewSymbol(":BEFORE") around := NewSymbol(":AROUND") after := NewSymbol(":AFTER") sort.Slice(methods, func(a, b int) bool { for i := range methods[a].classList { if ilos.SubclassOf(methods[a].classList[i], methods[b].classList[i]) { return false } if ilos.SubclassOf(methods[b].classList[i], methods[a].classList[i]) { return true } } t := map[ilos.Instance]int{around: 4, before: 3, nil: 2, after: 1} return t[methods[a].qualifier] > t[methods[b].qualifier] }) nextMethodPisNil := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return Nil, nil }) nextMethodPisT := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return T, nil }) if f.methodCombination == NewSymbol("NIL") { var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) // To Recursive callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { // CALL-NEXT-METHOD depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) + 1 // Get index of next method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if int(depth.(Integer))+1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) } return methods[index].function.Apply(e, arguments ...) // Call next method } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(0)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if 1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT))
  62. THE INTERNALS OF IRIS GENERIC FUNCTION e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) }

    return methods[0].function.Apply(e, arguments ...) //Call first of method } // if f.methodCombination == NewSymbol("STANDARD") { test := func(i int) bool { return methods[i].qualifier == around } width := len(methods) if index := sort.Search(width, test); index < width { // if has :around methods // This callNextMethod is called in :around methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth for index, method := range methods[:int(depth.(Integer))+1] { if method.qualifier == around { // If have :around method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil || methods[index+i+1].qualifier == around } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) // Call next method } } // If has no :around method then, // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } // Do the first of primary methods // this callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) // Get index of next mehotd e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) // Call next method } // callNextMethod ends here index := 0 // index of the first primary method { // index != 0 is always true because this function has :around methods width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } // Do primary methods ret, err := methods[index].function.Apply(e, arguments ...) if err != nil { return nil, err } // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) } } { // Function has no :around methods // This callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 index = sort.Search(width, test) } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) } // callNextMethod ends here // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } index := 0 // index of the first primary method { test := func(i int) bool { return methods[i].qualifier == nil } width := len(methods) index := sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) if index == len(methods) { return nil, NewUndefinedFunction(f.funcSpec) } } e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functions test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } ret, err := methods[index].function.Apply(e, arguments ...) // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this // file, You can obtain one at http: //mozilla.org/MPL/2.0/. package instance import ( "fmt" "reflect" "sort" "github.com/ta2gch/iris/runtime/env" "github.com/ta2gch/iris/runtime/ilos" ) type Applicable interface { Apply(env.Environment, ...ilos.Instance) (ilos.Instance, ilos.Instance) } type Function struct { name ilos.Instance function interface{} } func NewFunction(name ilos.Instance, function interface{}) ilos.Instance { return Function{name, function} } func (Function) Class() ilos.Class { return FunctionClass } func (f Function) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f Function) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { fv := reflect.ValueOf(f.function) ft := reflect.TypeOf(f.function) argv := []reflect.Value{reflect.ValueOf(e)} for _, cadr := range arguments { argv = append(argv, reflect.ValueOf(cadr)) } if ft.NumIn() != len(argv) && (!ft.IsVariadic() || ft.NumIn()-2 >= len(argv)) { return nil, NewArityError() } rets := fv.Call(argv) a, _ := rets[0].Interface().(ilos.Instance) b, _ := rets[1].Interface().(ilos.Instance) return a, b } type method struct { qualifier ilos.Instance classList []ilos.Class function Function } type GenericFunction struct { funcSpec ilos.Instance lambdaList ilos.Instance methodCombination ilos.Instance genericFunctionClass ilos.Class methods []method } func NewGenericFunction(funcSpec, lambdaList, methodCombination ilos.Instance, genericFunctionClass ilos.Class) ilos.Instance { return &GenericFunction{funcSpec, lambdaList, methodCombination, genericFunctionClass, []method{}} } func (f *GenericFunction) AddMethod(qualifier, lambdaList ilos.Instance, classList []ilos.Class, function ilos.Instance) bool { if f.lambdaList.(List).Length() != lambdaList.(List).Length() { return false } for i, param := range f.lambdaList.(List).Slice() { if param == NewSymbol(":REST") || param == NewSymbol("&REST") { if lambdaList.(List).Nth(i) != NewSymbol(":REST") && lambdaList.(List).Nth(i) != NewSymbol("&REST") { return false } } } for i := range f.methods { if f.methods[i].qualifier == qualifier && reflect.DeepEqual(f.methods[i].classList, classList) { f.methods[i].function = function.(Function) return true } } f.methods = append(f.methods, method{qualifier, classList, function.(Function)}) return true } func (f *GenericFunction) Class() ilos.Class { return f.genericFunctionClass } func (f *GenericFunction) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f *GenericFunction) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { parameters := f.lambdaList.(List).Slice() variadic := false { test := func(i int) bool { return parameters[i] == NewSymbol(":REST") || parameters[i] == NewSymbol("&REST") } if sort.Search(len(parameters), test) < len(parameters) { variadic = true } } if (variadic && len(parameters)-2 > len(arguments)) || (!variadic && len(parameters) != len(arguments)) { return nil, NewArityError() } methods := []method{} for _, method := range f.methods { matched := true for i, c := range method.classList { if !ilos.InstanceOf(c, arguments[i]) { matched = false break } } if matched { methods = append(methods, method) } } before := NewSymbol(":BEFORE") around := NewSymbol(":AROUND") after := NewSymbol(":AFTER") sort.Slice(methods, func(a, b int) bool { for i := range methods[a].classList { if ilos.SubclassOf(methods[a].classList[i], methods[b].classList[i]) { return false } if ilos.SubclassOf(methods[b].classList[i], methods[a].classList[i]) { return true } } t := map[ilos.Instance]int{around: 4, before: 3, nil: 2, after: 1} return t[methods[a].qualifier] > t[methods[b].qualifier] }) nextMethodPisNil := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return Nil, nil }) nextMethodPisT := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return T, nil }) if f.methodCombination == NewSymbol("NIL") { var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) // To Recursive callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { // CALL-NEXT-METHOD depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) + 1 // Get index of next method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if int(depth.(Integer))+1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) } return methods[index].function.Apply(e, arguments ...) // Call next method } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(0)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if 1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) แׅؔ਺ͷؔ਺ݺͼग़͠ͷ࣮૷ ຖճCALL-NEXT-METHODΛہॴؔ਺ͱͯ͠
 ༏ઌॱҐΛݩʹ௨ৗؔ਺ͱͯؔ͠਺Λଋറ͠ ͍ͯΔɻ࣮૷ʹΑΔ͕ɺҰൠʹಈతʹݺͼग़ ؔ͢਺Λܾఆ͍ͯ͠ΔͷͰίϯύΠϧʹΑΔ Ըܙ΋ड͚ͮΒ͍ɻ
  63. THE INTERNALS OF IRIS GENERIC FUNCTION e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) }

    return methods[0].function.Apply(e, arguments ...) //Call first of method } // if f.methodCombination == NewSymbol("STANDARD") { test := func(i int) bool { return methods[i].qualifier == around } width := len(methods) if index := sort.Search(width, test); index < width { // if has :around methods // This callNextMethod is called in :around methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth for index, method := range methods[:int(depth.(Integer))+1] { if method.qualifier == around { // If have :around method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil || methods[index+i+1].qualifier == around } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) // Call next method } } // If has no :around method then, // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } // Do the first of primary methods // this callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) // Get index of next mehotd e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) // Call next method } // callNextMethod ends here index := 0 // index of the first primary method { // index != 0 is always true because this function has :around methods width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } // Do primary methods ret, err := methods[index].function.Apply(e, arguments ...) if err != nil { return nil, err } // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) } } { // Function has no :around methods // This callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 index = sort.Search(width, test) } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) } // callNextMethod ends here // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } index := 0 // index of the first primary method { test := func(i int) bool { return methods[i].qualifier == nil } width := len(methods) index := sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) if index == len(methods) { return nil, NewUndefinedFunction(f.funcSpec) } } e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functions test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } ret, err := methods[index].function.Apply(e, arguments ...) // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this // file, You can obtain one at http: //mozilla.org/MPL/2.0/. package instance import ( "fmt" "reflect" "sort" "github.com/ta2gch/iris/runtime/env" "github.com/ta2gch/iris/runtime/ilos" ) type Applicable interface { Apply(env.Environment, ...ilos.Instance) (ilos.Instance, ilos.Instance) } type Function struct { name ilos.Instance function interface{} } func NewFunction(name ilos.Instance, function interface{}) ilos.Instance { return Function{name, function} } func (Function) Class() ilos.Class { return FunctionClass } func (f Function) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f Function) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { fv := reflect.ValueOf(f.function) ft := reflect.TypeOf(f.function) argv := []reflect.Value{reflect.ValueOf(e)} for _, cadr := range arguments { argv = append(argv, reflect.ValueOf(cadr)) } if ft.NumIn() != len(argv) && (!ft.IsVariadic() || ft.NumIn()-2 >= len(argv)) { return nil, NewArityError() } rets := fv.Call(argv) a, _ := rets[0].Interface().(ilos.Instance) b, _ := rets[1].Interface().(ilos.Instance) return a, b } type method struct { qualifier ilos.Instance classList []ilos.Class function Function } type GenericFunction struct { funcSpec ilos.Instance lambdaList ilos.Instance methodCombination ilos.Instance genericFunctionClass ilos.Class methods []method } func NewGenericFunction(funcSpec, lambdaList, methodCombination ilos.Instance, genericFunctionClass ilos.Class) ilos.Instance { return &GenericFunction{funcSpec, lambdaList, methodCombination, genericFunctionClass, []method{}} } func (f *GenericFunction) AddMethod(qualifier, lambdaList ilos.Instance, classList []ilos.Class, function ilos.Instance) bool { if f.lambdaList.(List).Length() != lambdaList.(List).Length() { return false } for i, param := range f.lambdaList.(List).Slice() { if param == NewSymbol(":REST") || param == NewSymbol("&REST") { if lambdaList.(List).Nth(i) != NewSymbol(":REST") && lambdaList.(List).Nth(i) != NewSymbol("&REST") { return false } } } for i := range f.methods { if f.methods[i].qualifier == qualifier && reflect.DeepEqual(f.methods[i].classList, classList) { f.methods[i].function = function.(Function) return true } } f.methods = append(f.methods, method{qualifier, classList, function.(Function)}) return true } func (f *GenericFunction) Class() ilos.Class { return f.genericFunctionClass } func (f *GenericFunction) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f *GenericFunction) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { parameters := f.lambdaList.(List).Slice() variadic := false { test := func(i int) bool { return parameters[i] == NewSymbol(":REST") || parameters[i] == NewSymbol("&REST") } if sort.Search(len(parameters), test) < len(parameters) { variadic = true } } if (variadic && len(parameters)-2 > len(arguments)) || (!variadic && len(parameters) != len(arguments)) { return nil, NewArityError() } methods := []method{} for _, method := range f.methods { matched := true for i, c := range method.classList { if !ilos.InstanceOf(c, arguments[i]) { matched = false break } } if matched { methods = append(methods, method) } } before := NewSymbol(":BEFORE") around := NewSymbol(":AROUND") after := NewSymbol(":AFTER") sort.Slice(methods, func(a, b int) bool { for i := range methods[a].classList { if ilos.SubclassOf(methods[a].classList[i], methods[b].classList[i]) { return false } if ilos.SubclassOf(methods[b].classList[i], methods[a].classList[i]) { return true } } t := map[ilos.Instance]int{around: 4, before: 3, nil: 2, after: 1} return t[methods[a].qualifier] > t[methods[b].qualifier] }) nextMethodPisNil := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return Nil, nil }) nextMethodPisT := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return T, nil }) if f.methodCombination == NewSymbol("NIL") { var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) // To Recursive callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { // CALL-NEXT-METHOD depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) + 1 // Get index of next method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if int(depth.(Integer))+1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) } return methods[index].function.Apply(e, arguments ...) // Call next method } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(0)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if 1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) แׅؔ਺ͷؔ਺ݺͼग़͠ͷ࣮૷ ຖճCALL-NEXT-METHODΛہॴؔ਺ͱͯ͠
 ༏ઌॱҐΛݩʹ௨ৗؔ਺ͱͯؔ͠਺Λଋറ͠ ͍ͯΔɻ࣮૷ʹΑΔ͕ɺҰൠʹಈతʹݺͼग़ ؔ͢਺Λܾఆ͍ͯ͠ΔͷͰίϯύΠϧʹΑΔ Ըܙ΋ड͚ͮΒ͍ɻ
  64. THE INTERNALS OF IRIS GENERIC FUNCTION e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) }

    return methods[0].function.Apply(e, arguments ...) //Call first of method } // if f.methodCombination == NewSymbol("STANDARD") { test := func(i int) bool { return methods[i].qualifier == around } width := len(methods) if index := sort.Search(width, test); index < width { // if has :around methods // This callNextMethod is called in :around methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth for index, method := range methods[:int(depth.(Integer))+1] { if method.qualifier == around { // If have :around method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil || methods[index+i+1].qualifier == around } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) // Call next method } } // If has no :around method then, // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } // Do the first of primary methods // this callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) // Get index of next mehotd e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) // Call next method } // callNextMethod ends here index := 0 // index of the first primary method { // index != 0 is always true because this function has :around methods width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } // Do primary methods ret, err := methods[index].function.Apply(e, arguments ...) if err != nil { return nil, err } // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) } } { // Function has no :around methods // This callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 index = sort.Search(width, test) } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) } // callNextMethod ends here // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } index := 0 // index of the first primary method { test := func(i int) bool { return methods[i].qualifier == nil } width := len(methods) index := sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) if index == len(methods) { return nil, NewUndefinedFunction(f.funcSpec) } } e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functions test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } ret, err := methods[index].function.Apply(e, arguments ...) // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this // file, You can obtain one at http: //mozilla.org/MPL/2.0/. package instance import ( "fmt" "reflect" "sort" "github.com/ta2gch/iris/runtime/env" "github.com/ta2gch/iris/runtime/ilos" ) type Applicable interface { Apply(env.Environment, ...ilos.Instance) (ilos.Instance, ilos.Instance) } type Function struct { name ilos.Instance function interface{} } func NewFunction(name ilos.Instance, function interface{}) ilos.Instance { return Function{name, function} } func (Function) Class() ilos.Class { return FunctionClass } func (f Function) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f Function) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { fv := reflect.ValueOf(f.function) ft := reflect.TypeOf(f.function) argv := []reflect.Value{reflect.ValueOf(e)} for _, cadr := range arguments { argv = append(argv, reflect.ValueOf(cadr)) } if ft.NumIn() != len(argv) && (!ft.IsVariadic() || ft.NumIn()-2 >= len(argv)) { return nil, NewArityError() } rets := fv.Call(argv) a, _ := rets[0].Interface().(ilos.Instance) b, _ := rets[1].Interface().(ilos.Instance) return a, b } type method struct { qualifier ilos.Instance classList []ilos.Class function Function } type GenericFunction struct { funcSpec ilos.Instance lambdaList ilos.Instance methodCombination ilos.Instance genericFunctionClass ilos.Class methods []method } func NewGenericFunction(funcSpec, lambdaList, methodCombination ilos.Instance, genericFunctionClass ilos.Class) ilos.Instance { return &GenericFunction{funcSpec, lambdaList, methodCombination, genericFunctionClass, []method{}} } func (f *GenericFunction) AddMethod(qualifier, lambdaList ilos.Instance, classList []ilos.Class, function ilos.Instance) bool { if f.lambdaList.(List).Length() != lambdaList.(List).Length() { return false } for i, param := range f.lambdaList.(List).Slice() { if param == NewSymbol(":REST") || param == NewSymbol("&REST") { if lambdaList.(List).Nth(i) != NewSymbol(":REST") && lambdaList.(List).Nth(i) != NewSymbol("&REST") { return false } } } for i := range f.methods { if f.methods[i].qualifier == qualifier && reflect.DeepEqual(f.methods[i].classList, classList) { f.methods[i].function = function.(Function) return true } } f.methods = append(f.methods, method{qualifier, classList, function.(Function)}) return true } func (f *GenericFunction) Class() ilos.Class { return f.genericFunctionClass } func (f *GenericFunction) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f *GenericFunction) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { parameters := f.lambdaList.(List).Slice() variadic := false { test := func(i int) bool { return parameters[i] == NewSymbol(":REST") || parameters[i] == NewSymbol("&REST") } if sort.Search(len(parameters), test) < len(parameters) { variadic = true } } if (variadic && len(parameters)-2 > len(arguments)) || (!variadic && len(parameters) != len(arguments)) { return nil, NewArityError() } methods := []method{} for _, method := range f.methods { matched := true for i, c := range method.classList { if !ilos.InstanceOf(c, arguments[i]) { matched = false break } } if matched { methods = append(methods, method) } } before := NewSymbol(":BEFORE") around := NewSymbol(":AROUND") after := NewSymbol(":AFTER") sort.Slice(methods, func(a, b int) bool { for i := range methods[a].classList { if ilos.SubclassOf(methods[a].classList[i], methods[b].classList[i]) { return false } if ilos.SubclassOf(methods[b].classList[i], methods[a].classList[i]) { return true } } t := map[ilos.Instance]int{around: 4, before: 3, nil: 2, after: 1} return t[methods[a].qualifier] > t[methods[b].qualifier] }) nextMethodPisNil := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return Nil, nil }) nextMethodPisT := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return T, nil }) if f.methodCombination == NewSymbol("NIL") { var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) // To Recursive callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { // CALL-NEXT-METHOD depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) + 1 // Get index of next method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if int(depth.(Integer))+1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) } return methods[index].function.Apply(e, arguments ...) // Call next method } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(0)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if 1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) แׅؔ਺ͷؔ਺ݺͼग़͠ͷ࣮૷ ຖճCALL-NEXT-METHODΛہॴؔ਺ͱͯ͠
 ༏ઌॱҐΛݩʹ௨ৗؔ਺ͱͯؔ͠਺Λଋറ͠ ͍ͯΔɻ࣮૷ʹΑΔ͕ɺҰൠʹಈతʹݺͼग़ ؔ͢਺Λܾఆ͍ͯ͠ΔͷͰίϯύΠϧʹΑΔ Ըܙ΋ड͚ͮΒ͍ɻ
  65. THE INTERNALS OF IRIS GENERIC FUNCTION e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) }

    return methods[0].function.Apply(e, arguments ...) //Call first of method } // if f.methodCombination == NewSymbol("STANDARD") { test := func(i int) bool { return methods[i].qualifier == around } width := len(methods) if index := sort.Search(width, test); index < width { // if has :around methods // This callNextMethod is called in :around methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth for index, method := range methods[:int(depth.(Integer))+1] { if method.qualifier == around { // If have :around method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil || methods[index+i+1].qualifier == around } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) // Call next method } } // If has no :around method then, // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } // Do the first of primary methods // this callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) // Get index of next mehotd e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) // Call next method } // callNextMethod ends here index := 0 // index of the first primary method { // index != 0 is always true because this function has :around methods width := len(methods) - index - 1 test := func(i int) bool { return methods[index+i+1].qualifier == nil } index = sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) } // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } // Do primary methods ret, err := methods[index].function.Apply(e, arguments ...) if err != nil { return nil, err } // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[index].function.Apply(e, arguments ...) } } { // Function has no :around methods // This callNextMethod is called in primary methods var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) // Convert depth to integer { test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 index = sort.Search(width, test) } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set Current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functionss test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } return methods[int(depth.(Integer))].function.Apply(e, arguments ...) } // callNextMethod ends here // Do All :before mehtods for _, method := range methods { if method.qualifier == before { if _, err := method.function.Apply(e, arguments ...); err != nil { return nil, err } } } index := 0 // index of the first primary method { test := func(i int) bool { return methods[i].qualifier == nil } width := len(methods) index := sort.Search(width, test) e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) if index == len(methods) { return nil, NewUndefinedFunction(f.funcSpec) } } e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil) { // If Generic Function has next method, set these functions test := func(i int) bool { return methods[index+i+1].qualifier == nil } width := len(methods) - index - 1 if sort.Search(width, test) < width { e.Function.Define(NewSymbol("NEXT-METHOD-P"), nextMethodPisT) e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) } } ret, err := methods[index].function.Apply(e, arguments ...) // Do all :after methods for i := len(methods) - 1; i >= 0; i -- { if methods[i].qualifier == after { if _, err := methods[i].function.Apply(e, arguments ...); err != nil { return nil, err } } } return ret, err // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this // file, You can obtain one at http: //mozilla.org/MPL/2.0/. package instance import ( "fmt" "reflect" "sort" "github.com/ta2gch/iris/runtime/env" "github.com/ta2gch/iris/runtime/ilos" ) type Applicable interface { Apply(env.Environment, ...ilos.Instance) (ilos.Instance, ilos.Instance) } type Function struct { name ilos.Instance function interface{} } func NewFunction(name ilos.Instance, function interface{}) ilos.Instance { return Function{name, function} } func (Function) Class() ilos.Class { return FunctionClass } func (f Function) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f Function) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { fv := reflect.ValueOf(f.function) ft := reflect.TypeOf(f.function) argv := []reflect.Value{reflect.ValueOf(e)} for _, cadr := range arguments { argv = append(argv, reflect.ValueOf(cadr)) } if ft.NumIn() != len(argv) && (!ft.IsVariadic() || ft.NumIn()-2 >= len(argv)) { return nil, NewArityError() } rets := fv.Call(argv) a, _ := rets[0].Interface().(ilos.Instance) b, _ := rets[1].Interface().(ilos.Instance) return a, b } type method struct { qualifier ilos.Instance classList []ilos.Class function Function } type GenericFunction struct { funcSpec ilos.Instance lambdaList ilos.Instance methodCombination ilos.Instance genericFunctionClass ilos.Class methods []method } func NewGenericFunction(funcSpec, lambdaList, methodCombination ilos.Instance, genericFunctionClass ilos.Class) ilos.Instance { return &GenericFunction{funcSpec, lambdaList, methodCombination, genericFunctionClass, []method{}} } func (f *GenericFunction) AddMethod(qualifier, lambdaList ilos.Instance, classList []ilos.Class, function ilos.Instance) bool { if f.lambdaList.(List).Length() != lambdaList.(List).Length() { return false } for i, param := range f.lambdaList.(List).Slice() { if param == NewSymbol(":REST") || param == NewSymbol("&REST") { if lambdaList.(List).Nth(i) != NewSymbol(":REST") && lambdaList.(List).Nth(i) != NewSymbol("&REST") { return false } } } for i := range f.methods { if f.methods[i].qualifier == qualifier && reflect.DeepEqual(f.methods[i].classList, classList) { f.methods[i].function = function.(Function) return true } } f.methods = append(f.methods, method{qualifier, classList, function.(Function)}) return true } func (f *GenericFunction) Class() ilos.Class { return f.genericFunctionClass } func (f *GenericFunction) String() string { return fmt.Sprintf("#%v", f.Class()) } func (f *GenericFunction) Apply(e env.Environment, arguments ...ilos.Instance) (ilos.Instance, ilos.Instance) { parameters := f.lambdaList.(List).Slice() variadic := false { test := func(i int) bool { return parameters[i] == NewSymbol(":REST") || parameters[i] == NewSymbol("&REST") } if sort.Search(len(parameters), test) < len(parameters) { variadic = true } } if (variadic && len(parameters)-2 > len(arguments)) || (!variadic && len(parameters) != len(arguments)) { return nil, NewArityError() } methods := []method{} for _, method := range f.methods { matched := true for i, c := range method.classList { if !ilos.InstanceOf(c, arguments[i]) { matched = false break } } if matched { methods = append(methods, method) } } before := NewSymbol(":BEFORE") around := NewSymbol(":AROUND") after := NewSymbol(":AFTER") sort.Slice(methods, func(a, b int) bool { for i := range methods[a].classList { if ilos.SubclassOf(methods[a].classList[i], methods[b].classList[i]) { return false } if ilos.SubclassOf(methods[b].classList[i], methods[a].classList[i]) { return true } } t := map[ilos.Instance]int{around: 4, before: 3, nil: 2, after: 1} return t[methods[a].qualifier] > t[methods[b].qualifier] }) nextMethodPisNil := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return Nil, nil }) nextMethodPisT := NewFunction(NewSymbol("NEXT-METHOD-P"), func(e env.Environment) (ilos.Instance, ilos.Instance) { return T, nil }) if f.methodCombination == NewSymbol("NIL") { var callNextMethod func(e env.Environment) (ilos.Instance, ilos.Instance) // To Recursive callNextMethod = func(e env.Environment) (ilos.Instance, ilos.Instance) { // CALL-NEXT-METHOD depth, _ := e.DynamicVariable.Get(NewSymbol("IRIS/DEPTH")) // Get previous depth index := int(depth.(Integer)) + 1 // Get index of next method e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(index)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if int(depth.(Integer))+1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("CALL-NEXT-METHOD"), NewFunction(NewSymbol("CALL-NEXT-METHOD"), callNextMethod)) e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT)) } return methods[index].function.Apply(e, arguments ...) // Call next method } e.DynamicVariable.Define(NewSymbol("IRIS/DEPTH"), NewInteger(0)) // Set current depth // If Generic Function has no next-mehtods, NEXT-METHOD-P e function returns nil e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisNil)) if 1 < len(methods) { // If Generic Function has next method, set these functionss e.Function.Define(NewSymbol("NEXT-METHOD-P"), NewFunction(NewSymbol("NEXT-METHOD-P"), nextMethodPisT))
  66. THE INTERNALS OF IRIS NON-LOCAL EXITS 1. block / return-from

    2. tagbody / go 3. catch / throw 4. with-handler / singnal-condition LEXICAL LEXICAL DYNAMIC DYNAMIC
  67. THE INTERNALS OF IRIS BLOCK / RETURN-FROM (block sum-block (for

    ((x '(1 a 2 3) (cdr x)) (sum 0 (+ sum (car x)))) ((null x) sum) (cond ((not (numberp (car x))) (return-from sum-block 0)))))
  68. THE INTERNALS OF IRIS TAGBODY / GO (defmacro with-retry (:rest

    forms) (let ((tag (gensym))) `(block ,tag (tagbody ,tag (return-from ,tag (flet ((retry () (go ,tag))) ,@forms)))))) (let ((i -5)) (with-retry ;; if-error is a hypothetical error correction function ;; not supplied by ISLISP. (if-error (sqrt (setq i (+ i 4))) (retry))))
  69. THE INTERNALS OF IRIS CATCH / THROW (defun foo (x)

    (catch 'block-sum (bar x))) (defun bar (x) (for ((l x (cdr l)) (sum 0 (+ sum (car l)))) ((null l) sum) (cond ((not (numberp (car l))) (throw 'block-sum 0))))) (foo '(1 2 3 4)) (foo '(1 2 a 4))
  70. THE INTERNALS OF IRIS WITH-HANDLER / SIGNAL-CONDITION (defun handler (c)

    ɹ(continue-condition c true)) (with-handler #'handler ɹ(cerror “continue-message“ “error-message”))
  71. THE INTERNALS OF IRIS NON-LOCAL EXITS 1. ҰൠʹCݴޠͰ࣮૷͢Δ৔߹͸setjmp/longjmpͱ͍͏Cݴ ޠࣗମͷελοΫΛר͖໭͢େҬ୤ग़Λ࢖ͬͯΠϯλϓϦ λࣗମͷελοΫ΋ר͖໭͢Α͏ʹ࣮ͯ͠૷͍ͯ͠Δ

    PROCEDURE A PROCEDURE B1 PROCEDURE B3 PROCEDURE B2 PROCEDURE C ENVIRONMENT A ENVIRONMENT B Jump
  72. THE INTERNALS OF IRIS NON-LOCAL EXITS 1. Goݴޠͷ৔߹setjmpͱlongjmp͕࢖͑ͳ͍ 2. ؀ڥʹcatch͍ͨ͠৔ॴΛελοΫʹϓογϡ͢Δɻ

    3. ୤ग़༻໭Γ஋ΛEvalͳͲ͕ॲཧΛৼΓ෼͚Δɻ PROCEDURE A PROCEDURE B1 PROCEDURE B1 PROCEDURE B1 PROCEDURE C FAIL SUCCESS MATCH ENVIRONMENT A ENVIRONMENT B SUCCESS
  73. IRIS IN THE FEATURE

  74. IRIS IN THE FEATURE PARALLELIZED MAP ▸ Goݴޠʹ͸ڧྗͳฒྻ࣮ߦγεςϜ͕૊Έࠐ·Ε͍ͯΔɻ ▸ GoroutineΛ࢖ͬͯΧδϡΞϧʹฒྻԽΛߦ͑ΔΑ͏ʹ͢Δ

    ▸ Clojure΍lparallelͷฒྻԽΛࢀߟʹ͢Δͭ΋Γ
  75. IRIS IN THE FEATURE PLUGIN & FFI SUPPORT ▸ Goݴޠʹ͸ಈతʹϥΠϒϥϦΛಡΈࠐΉγεςϜ΋͋Δ

    ▸ PluginΛ࢖ͬͯศརͳϥΠϒϥϦͷϥούʔΛॻ͘ ▸ Goͷඪ४ϥΠϒϥϦʹ͸ศརͳ΋ͷ͕ͨ͘͞Μ͋Δɻ ▸ ը૾ॲཧ ▸ ҉߸Խ ▸ ଟഒ௕੔਺ ▸ HTTP & SMTPͳͲͷωοτϫʔΫϓϩτίϧͷ࣮૷ ▸ ɹCGOΛ࢖͑͹CݴޠͷϥΠϒϥϦ΋ಡΈࠐΊΔɻ ▸ جຊతʹωΠςΟϒؔ਺ΛILOSͷؔ਺ΠϯελϯεͰแΉ͚ͩͳͷͰ؆୯ʹϥοϐϯάͰ͖Δ
  76. IRIS IN THE FEATURE PACKAGE SYSTEM ▸ ͔ͭͯJavaScriptʹ͸ύοέʔδ؅ཧγεςϜ͕ͳ͔ͬͨ ▸ Webpack΍browserifyɺRequireJSͱ͍ͬͨJavaScript͚ͩ

    Ͱ࣮૷͞ΕͨASTϨϕϧͷม׵ͷΈͰύοέʔδ؅ཧΛ࣮ݱ ͍ͯͨ͠ɻ ▸ ISLisp΋ISLispͷΈΛ࢖ͬͯASTϨϕϧͷม׵ͷΈͰύο έʔδ؅ཧΛ࣮ݱ͢Δ
  77. IRIS islisp.js.org