;;; sml-mode.el --- Major mode for editing (Standard) ML -*- lexical-binding: t; coding: utf-8 -*-
-;; Copyright (C) 1989,1999,2000,2004,2007,2010-2013 Free Software Foundation, Inc.
+;; Copyright (C) 1989,1999,2000,2004,2007,2010-2014 Free Software Foundation, Inc.
;; Maintainer: (Stefan Monnier) <monnier@iro.umontreal.ca>
;; Version: 6.4
(decls "nonfix" decls)
(decls "abstype" decls)
(decls "datatype" decls)
+ (decls "include" decls)
+ (decls "sharing" decls)
(decls "exception" decls)
(decls "fun" decls)
(decls "val" decls))
'((assoc "->") (assoc "*"))
'((assoc "val" "fun" "type" "datatype" "abstype" "open" "infix" "infixr"
"nonfix" "functor" "signature" "structure" "exception"
- ;; "local"
+ "include" "sharing" "local"
)
(assoc "and"))
'((assoc "orelse") (assoc "andalso") (nonassoc ":"))
((member token '("|" "d|" ";" ",")) (smie-rule-separator kind))
;; Treat purely syntactic block-constructs as being part of their parent,
;; when the opening statement is hanging.
- ((member token '("let" "(" "[" "{"))
+ ((member token '("let" "(" "[" "{")) ; "struct"? "sig"?
(if (smie-rule-hanging-p) (smie-rule-parent)))
;; Treat if ... else if ... as a single long syntactic construct.
;; Similarly, treat fn a => fn b => ... as a single construct.
((equal token "d=")
(cond
((smie-rule-parent-p "datatype") (if (smie-rule-bolp) 2))
- ((smie-rule-parent-p "structure" "signature") 0)))
+ ((smie-rule-parent-p "structure" "signature" "functor") 0)))
;; Indent an expression starting with "local" as if it were starting
;; with "fun".
((equal token "local") (smie-indent-keyword "fun"))
;; One known problem case is code like:
;; "functor foo (structure s : S) where type t = s.t ="
;; where the "type t = s.t" is mistaken for a type definition.
- (let ((re (concat "\\(" sml-=-starter-re "\\)\\|=")))
- (save-excursion
- (and (re-search-backward re nil t)
- (or (match-beginning 1)
- ;; If we first hit a "=", then that = is probably definitional
- ;; and we're an equality, but not necessarily. One known
- ;; problem case is code like:
- ;; "functor foo (structure s : S) where type t = s.t ="
- ;; where the first = is more like an equality (tho it doesn't
- ;; matter much) and the second is definitional.
- ;;
- ;; FIXME: The test below could be used to recognize that the
- ;; second = is not a mere equality, but that's not enough to
- ;; parse the construct properly: we'd need something
- ;; like a third kind of = token for structure definitions, in
- ;; order for the parser to be able to skip the "type t = s.t"
- ;; as a sub-expression.
- ;;
- ;; (and (not (looking-at "=>"))
- ;; (not (eq ?< (char-before))) ;Not a <=
- ;; (re-search-backward re nil t)
- ;; (match-beginning 1)
- ;; (equal "type" (buffer-substring (- (match-end 1) 4)
- ;; (match-end 1))))
- )))))
+ (save-excursion
+ (let ((res (smie-backward-sexp "=")))
+ (member (nth 2 res) `(":" ,@sml-=-starter-syms)))))
(defun sml-smie-non-nested-of-p ()
;; FIXME: Maybe datatype-|-p makes this nested-of business unnecessary.
-(* Copyright 1999,2004,2007,2010-2012 Stefan Monnier <monnier@gnu.org> *)
+(* Copyright 1999,2004,2007,2010-2012,2014 Stefan Monnier <monnier@gnu.org> *)
(* sml-mode here treats the second `=' as an equal op because it
* thinks it's seeing something like "... type t = (s.t = ...)". FIXME! *)
c
;4)
+structure Attrs : sig
+ type t
+ datatype node
+ = Attributes of string list
+ include WRAPPED
+ sharing type node' = node
+ sharing type obj = t
+ end
+
+functor DoWrap1(type node) : S = struct
+type t = node Wrap.t
+open Wrap
+type node' = node
+type obj = t
+end
+
+functor DoWrap(type node) : sig
+ type t = node Wrap.t
+ include WRAPPED
+ sharing type node' = node
+ sharing type obj = t
+ end =
+struct
+type t = node Wrap.t
+open Wrap
+type node' = node
+type obj = t
+end
+
val ber = 1;
val sdfg = 1
val tut = fn (x,y) z y e r =>