package yuujinchou

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Introduction
1. Motivation
2. Design Principles
Example Code
Rosetta of Imports
1. Haskell
2. Racket
API Reference
Installation
What is "Yuujinchou"?

package yuujinchou

yuujinchou
- Yuujinchou
  - Language
  - Modifier
    
    Make
    
    P
    
    Param
    
    S
  - Scope
    
    Make
    
    P
    
    S
  - Trie
    
    Untagged

Legend:
Library
Module
Module type
Parameter
Class
Class type

Yuujinchou: Name Modifiers

Introduction

Motivation

This library was motivated by the name modifiers in the "import" or "include" statements present in all practical programming languages. Here are a few examples of such statements but without modifiers:

open import M -- Agda

import foo # Python

The ability to import content from other files helps organize code. However, it also poses a new challenge: how could programmers prevent imported content from shadowing existing content? For example, if we already have a function test in the current scope, maybe we do not wish to import another function also named test. To address this, many programming languages allow programmers to selectively hide or rename part of the imported content:

open import M renaming (a to b) public
-- (Agda) renaming a to b, and then re-exporting the content

Another way to address this is to place the imported content under some namespace. For example, in Python,

import math # Python: the sqrt function is available as `math.sqrt`.

Arguably, common designs of these hiding or renaming mechanisms are quite limited. The goal of the Yuujinchou library is to provide a compositional calculus of these modifiers of names. Currently, the library supports renaming, scopes, sequencing, unions, and custom hooks for extending the engine.

Design Principles

See the design document for the principles and ideas we follow when making this library.

Example Code

Here is a tiny interpreter for a language with nested lexical scopes.

open Yuujinchou
open Bwd

(* A tiny language demonstrating some power of the Scope module. *)
type modifier_cmd = Print
type decl =
  (* declaration *)
  | Decl of Trie.path * int
  (* declaration, but supressing the shadowing warning *)
  | ShadowingDecl of Trie.path * int
  (* importing a trie after applying the modifier *)
  | Import of int Trie.Untagged.t * modifier_cmd Language.t
  (* printing out all visible bindings *)
  | PrintVisible
  (* exporting a binding *)
  | Export of Trie.path
  (* section *)
  | Section of Trie.path * decl list
type program = decl list

(* Specialzed Scope module with Data.t *)
module S = Scope.Make (struct
    type data = int
    type tag = [`Imported | `Local]
    type hook = modifier_cmd
    type context = [`Visible | `Export]
  end)

(* Handle scoping effects *)
let handler : _ Scope.handler =
  let pp_path fmt =
    function
    | Emp -> Format.pp_print_string fmt "(root)"
    | path -> Format.pp_print_string fmt @@ String.concat "." (Bwd.to_list path)
  in
  let pp_context fmt =
    function
    | Some `Visible -> Format.pp_print_string fmt " in the visible namespace"
    | Some `Export -> Format.pp_print_string fmt " in the export namespace"
    | None -> ()
  in
  let pp_item fmt =
    function
    | (x, `Imported) -> Format.fprintf fmt "%i (imported)" x
    | (x, `Local) -> Format.fprintf fmt "%i (local)" x
  in
  { not_found =
      (fun context prefix ->
         Format.printf
           "[Warning] Could not find any data within the subtree at %a%a.@."
           pp_path prefix pp_context context);
    shadow =
      (fun context path x y ->
         Format.printf
           "[Warning] Data %a assigned at %a was shadowed by data %a%a.@."
           pp_item x
           pp_path path
           pp_item y
           pp_context context;
         y);
    hook =
      (fun context prefix hook input ->
         match hook with
         | Print ->
           Format.printf "@[<v 2>[Info] Got the following bindings at %a%a:@;"
             pp_path prefix pp_context context;
           Trie.iter
             (fun path x ->
                Format.printf "%a => %a@;" pp_path path pp_item x)
             input;
           Format.printf "@]@.";
           input)}

(* Mute the [shadow] effects. *)
let silence_shadow f = S.try_with f {S.perform with shadow = fun _ _ _ y -> y}

(* The interpreter *)
let rec interpret_decl : decl -> unit =
  function
  | Decl (p, x) ->
    S.include_singleton ~context_visible:`Visible ~context_export:`Export (p, (x, `Local))
  | ShadowingDecl (p, x) ->
    silence_shadow @@ fun () ->
    S.include_singleton (p, (x, `Local))
  | Import (t, m) ->
    let t = S.modify m (Trie.Untagged.tag `Imported t) in
    S.import_subtree ([], t)
  | PrintVisible ->
    S.modify_visible (Language.hook Print)
  | Export p ->
    S.export_visible (Language.only p)
  | Section (p, sec) ->
    S.section p @@ fun () -> List.iter interpret_decl sec

let interpret (prog : program) =
  S.run (fun () -> List.iter interpret_decl prog) handler

Rosetta of Imports

This section shows how mechanisms in other languages can be implemented using this package. We use Haskell and Racket as examples.