leque

module With_position = struct
  type 'a t =
    { value : 'a
    ; pos : Lexing.position
    }
end

type 'dict atom =
  [ `Symbol of string
  | `Vector of 't array

leque

class type a_setter = object
  method setter : unit
end

class type a_getter = object
  method getter : unit
end

class type a_lens = object
  inherit a_getter

leque

(*
    OCaml van Laarhoven CPS lenses. https://gist.github.com/tel/08d2a94de21f483cbb20
   plus eta expansion
   https://stackoverflow.com/questions/29187287/sneaking-lenses-and-cps-past-the-value-restriction
   *)

type (-'s, +'t, +'a, -'b) _t =
  { op : 'r. ('a -> ('b -> 'r) -> 'r) -> ('s -> ('t -> 'r) -> 'r) }

type (-'s, +'t, +'a, -'b) t = unit -> ('s, 't, 'a, 'b) _t

leque

#!r6rs
(library (binding)
  (export bound?)
  (import
    (for (only (rnrs base) eq? list not quote lambda eqv? unquote quasiquote) expand)
    (for (only (rnrs base) define-syntax) run)
    (for (only (rnrs lists) exists) expand)
    (for (only (rnrs syntax-case)
               quasisyntax unsyntax
               syntax-case syntax free-identifier=? syntax->datum datum->syntax)

leque

module TaggedInitial = struct
  type _ t =
    | Int : int -> int t
    | Bool : bool -> bool t
    | Eql : ('a t * 'a t) -> bool t
    | If : (bool t * 'a t * 'a t) -> 'a t

  let term =
    If (Bool true, Int 42, Int 0)

leque

module Make() : sig
  type field = ..

  type 'a field_access =
      { get : field -> 'a option
      ; set : 'a -> field
      ; default : 'a
      }

  type t

leque

object Main {
  // 型クラスの定義
  trait Show[A] {
    def show(x: A): String
  }

  // 型クラスのインスタンス: Int
  implicit def ShowInt: Show[Int] = new Show[Int] {
    def show(x: Int) = x.toString
  }

leque

module type Show = sig
  type t
  val show : t -> string
end

module ShowInt : Show with type t = int = struct
  type t = int

  let show = Int.to_string
end

leque

(use www.css)
(select-module www.css)
(define %an+b
  (let ()
    (define %+ ($seq ($delim #\+) ($return +)))
    (define %- ($seq ($delim #\-) ($return -)))
    (define %opt-sign
      ($optional ($or %+ %-) +))
    (define %n   ($match1 ('IDENT . 'n)))
    (define %-n  ($match1 ('IDENT . '-n)))

leque

type t =
  | Leaf of int * string
  | Concat of int * t * t

let length = function
  | Leaf (i, _) -> i
  | Concat (i, _, _) -> i

let leaf s =
  Leaf (String.length s, s)