@effekt-lang/effekt 0.2.1 → 0.3.0

package/libraries/llvm/sanity.c

@@ -0,0 +1,16 @@
+#ifndef EFFEKT_SANITY_C
+#define EFFEKT_SANITY_C
+
+
+#if CHAR_BIT != 8
+#error Machine ought to have eight bits in a byte.
+#endif
+
+
+#define ASSERT_NON_NULL(PTR) if ((PTR) == NULL) { \
+    fprintf(stderr, "*** MALLOC PANIC\n"); \
+    fflush(stderr); \
+    exit(1); }
+
+
+#endif

package/libraries/llvm/types.c

@@ -0,0 +1,43 @@
+#ifndef EFFEKT_TYPES_C
+#define EFFEKT_TYPES_C
+
+
+typedef int64_t Int;
+typedef double Double;
+
+struct Header {
+  uint64_t rc;
+  void (*eraser)(void *);
+};
+
+struct Pos {
+    uint64_t tag; // type-local tag
+    void *obj; // pointer into the heap
+};
+
+struct Neg {
+    void *vtable;
+    void *obj;
+};
+
+static const struct Pos Unit = (struct Pos) { .tag = 0, .obj = NULL, };
+static const struct Pos BooleanFalse = (struct Pos) { .tag = 0, .obj = NULL, };
+static const struct Pos BooleanTrue = (struct Pos) { .tag = 1, .obj = NULL, };
+
+typedef struct Pos String;
+
+
+// Defined in rts.ll
+
+extern void run(struct Neg);
+extern void run_i64(struct Neg, int64_t);
+extern void run_Pos(struct Neg, struct Pos);
+
+// Reference counting primitives defined in LLVM
+extern void eraseNegative(struct Neg);
+extern void erasePositive(struct Pos);
+
+extern void shareNegative(struct Neg);
+extern void sharePositive(struct Pos);
+
+#endif

package/libraries/ml/effekt.sml

@@ -0,0 +1,65 @@
+(* EVIDENCE *)
+fun lift m k1 k2 = m (fn a => k1 a k2);
+fun nested ev1 ev2 m = ev1 (ev2 m);
+fun here x = x;
+
+(* REGIONS *)
+(* type region = ((() -> () -> ()) list) ref *)
+fun newRegion () = ref nil
+fun backup cell = fn () => let val oldState = !cell in fn () => cell := oldState end
+fun fresh r init = let val cell = ref init in (r := (backup cell) :: (!r); cell) end
+fun withRegion body =
+    let val r = newRegion()
+        fun lift m k = let val fields = map (fn f => f()) (!r) in
+            m (fn a => (map (fn f => f()) fields; k a)) end
+    in body lift r end
+
+(* SHOW INSTANCES *)
+fun show'int x =
+    let val s = (Int.toString x) in
+    case String.sub (s, 0) of
+          #"~" => "-" ^ String.extract (s, 1, NONE)
+        | _ => s
+    end;
+
+(*
+To align with the js backend inf and nan is rewritten
+- `nan` -> `NaN`
+- `inf` -> `Infinity`
+- `~2.1` -> `-2.1`
+They do still disagree on the truncating of `2.0` to `2` (ml does not).
+*)
+fun show'real x =
+    let val s = (Real.toString x) in
+    case s of
+          "nan" => "NaN"
+        | "inf" => "Infinity"
+        | _ => case String.sub (s, 0) of
+              #"~" => "-" ^ String.extract (s, 1, NONE)
+            | _ => s
+    end;
+
+fun show'unit x = ""
+
+fun show'bool x = Bool.toString x
+
+fun show'string x = x
+
+(* TIMING *)
+val mlStartTime = Time.toMilliseconds (Time.now ());
+
+(* RANDOM *)
+fun mlRandomReal () =
+   let
+      val r = MLton.Random.rand ();
+      val rreal = MLton.Real.fromWord r;
+      val wsize = Real.fromInt Word.wordSize;
+      fun shiftRight r shift = r / (Math.pow(2.0, shift))
+   in
+      shiftRight rreal wsize
+   end;
+
+(* HOLES *)
+exception Hole
+
+exception Absurd

package/libraries/ml/internal/mllist.effekt

@@ -0,0 +1,9 @@
+module internal/mllist
+
+extern type MLList[Elem] // = 'elem list
+extern pure def isEmpty[A](l: MLList[A]): Bool = ml "null ${l}"
+extern pure def head[A](l: MLList[A]): A = ml "hd ${l}"
+extern pure def tail[A](l: MLList[A]): MLList[A] = ml "tl ${l}"
+
+def toList[A](l: MLList[A]): List[A] =
+  if (l.isEmpty) Nil() else Cons(l.head, toList(l.tail))

package/libraries/ml/internal/mloption.effekt

@@ -0,0 +1,18 @@
+module internal/mloption
+
+import effekt
+import option
+
+extern type MLOption[T]
+
+extern pure def isDefined[T](opt: MLOption[T]): Bool =
+  ml "Option.isSome ${opt}"
+
+def isEmpty[T](opt: MLOption[T]): Bool = not(opt.isDefined())
+
+extern pure def force[T](opt: MLOption[T]): T =
+  ml "Option.valOf ${opt}"
+
+def toOption[T](opt: MLOption[T]): Option[T] = {
+    if (isDefined(opt)) Some(force(opt)) else None()
+}

package/libraries/ml/random.effekt

@@ -0,0 +1,85 @@
+module random
+
+/**
+ * Imperative Random Numbers
+ * -------------------------
+ * The following are simple bindings for the following SML/NJ module:
+ *   https://www.smlnj.org/doc/smlnj-lib/Util/str-Random.html
+ *
+ * They are not supposed to be used directly, but only via the
+ * effect [[Random]], below.
+ */
+extern type RNG // = int * int
+extern io def seed(n: Int, m: Int): RNG = ml "Random.rand (${n}, ${m})"
+extern pure def toString(s: RNG): String = ml "Random.toString ${s}"
+
+extern io def int(s: RNG): Int = ml "Random.randInt ${s}"
+extern io def int(s: RNG, from: Int, to: Int): Int = ml "Random.randRange (${from}, ${to}) ${s}"
+extern io def double(s: RNG): Double = ml "Random.randReal ${s}"
+
+
+/**
+ * Functional Random Numbers
+ * -------------------------
+ * The following are simple bindings for the following SML/NJ module:
+ *   https://www.smlnj.org/doc/smlnj-lib/Util/str-Rand.html
+ *
+ * They are not supposed to be used directly, but only via the
+ * effect [[Random]], below.
+ */
+extern type PseudoRNG
+extern pure def random(s: PseudoRNG): PseudoRNG =
+  ml "Rand.random ${s}"
+extern pure def range(s: PseudoRNG, n: Int, m: Int): Int =
+  ml "Rand.range (${n}, ${m}) ${s}"
+extern pure def norm(s: PseudoRNG): Double =
+  ml "Rand.norm ${s}"
+
+// converting two integers into a word that is between randMin and randMax is completely made up
+extern pure def pseudo(n: Int, m: Int): PseudoRNG =
+  ml "Word.fromInt ((Word.toInt Rand.randMin) + ((abs (${n} * ${m})) mod (Word.toInt Rand.randMax)))"
+
+
+
+// "Public" API
+// ------------
+
+/**
+ * A random number generator.
+ *
+ * Supposed to be used as an effect: `do randomInt(0, 10)`.
+ * There are two canonical implementations as effect handlers (see below).
+ */
+interface Random {
+  // returns a random integer between `from` and `to`
+  def randomInt(from: Int, to: Int): Int
+  // returns a random double between 0.0 and 1.0
+  def randomDouble(): Double
+}
+
+/**
+ * Imperative random numbers. Does not perform backtracking.
+ */
+def withRandom[R](n: Int, m: Int) { prog: => R / Random } = {
+  // should be second class, is mutated...
+  val rng = seed(n, m)
+  try { prog() }
+  with Random {
+    def randomInt(from, to) = resume(rng.int(from, to))
+    def randomDouble() = resume(rng.double())
+  }
+}
+
+/**
+ * Functional, pseudo random numbers. According to SMLNJ docs it is faster than the imperative version
+ */
+def withPseudoRandom[R](n: Int, m: Int) { prog: => R / Random } = {
+  // should be second class, is mutated...
+  var rng = pseudo(n, m)
+  def next() = rng = random(rng);
+  try { prog() }
+  with Random {
+    def randomInt(from, to) = { next(); resume(rng.range(from, to)) }
+    def randomDouble() = { next(); resume(rng.norm()) }
+  }
+}

package/libraries/ml/text/regex.effekt

@@ -0,0 +1,102 @@
+module text/regex
+
+import internal/mllist
+import internal/mloption
+
+extern type Char // TODO move to text/string
+type Chars = MLList[Char]
+
+
+extern pure def chars(str: String): Chars = ml "String.explode ${str}"
+extern pure def toString(chars: Chars): String = ml "String.implode ${chars}"
+
+extern ml """
+
+(** The RegExp module is created by choosing a parser (P) and an engine (E)
+  * for regular expressions.
+  *
+  * There is no big choice for the parser, since only Awk syntax is supported.
+  * For the regular expression engine, we choose Ken Thompson's algorighm.
+  *
+  * Also see:
+  *   <https://stackoverflow.com/questions/35462919/how-to-use-regex-in-smlnj>
+  *   <https://www.smlnj.org/doc/smlnj-lib/RegExp/fun-RegExpFn.html>
+  *)
+structure RegExp = RegExpFn(
+  structure P = AwkSyntax
+  structure E = ThompsonEngine
+  (* structure E = BackTrackEngine *)
+  (* structure E = DfaEngine *)
+)
+"""
+
+// The type of regular expressions (ML representation)
+extern type Regex
+
+record Match(matched: String)
+
+// TODO handle CannotParse and CannotCompile ml exceptions.
+extern pure def regex(regexString: String): Regex =
+  ml "RegExp.compileString ${regexString}"
+
+
+// A stream of elements of type Elem, read from a source of type Source
+extern type MLStream[Elem, Source] // = ('elem, 'source) StringCvt.reader
+
+// Internal ml type that represents matches
+//   <https://www.smlnj.org/doc/smlnj-lib/RegExp/str-MatchTree.html>
+extern type MLMatchResult // = match * char list
+
+extern ml """
+type regex_match = {len: int, pos: char list} MatchTree.match_tree;
+fun matchedString (match : regex_match * char list) =
+  let val res = MatchTree.root (#1 match)
+  in String.implode (List.take (#pos res, #len res)) end;
+
+fun remainderChars (match : regex_match * char list) =
+  let val res = MatchTree.root (#1 match)
+  in List.drop (#pos res, #len res) end;
+
+(** The remainder is just a draft and doesn't work yet...) *)
+
+(** MatchTree -> string list **)
+fun allMatched (matchtree: regex_match) =
+  MatchTree.foldl (fn (m, b) => (String.implode (List.take (#pos m, #len m))) :: b) nil matchtree
+fun allBut str = RegExp.compileString ("[^" ^ str ^ "]+");
+
+fun unsafeSplit str sep =
+  case (RegExp.find (allBut str) List.getItem (String.explode str)) of
+      NONE => nil
+    | SOME v => allMatched (#1 v);
+"""
+
+extern pure def getMatch(result: MLMatchResult): String =
+  ml "matchedString ${result}"
+extern pure def getRemainder(result: MLMatchResult): Chars =
+  ml "remainderChars ${result}"
+
+extern pure def unsafeSplit(str: String, ch: Char): MLList[String] =
+  ml "String.fields (fn c => c = ${ch}) ${str}"
+
+extern pure def unsafeMatchPrefix(r: Regex, str: Chars): MLOption[MLMatchResult] =
+  ml "RegExp.prefix ${r} List.getItem ${str}"
+
+extern pure def unsafeSplit(str: String, sep: String): MLList[String] =
+  ml "unsafeSplit ${str} ${sep}"
+
+extern ml """
+val NEWLINE_CHAR = #"\n";
+"""
+
+extern pure def unsafeLines(str: String): MLList[String] =
+  ml "String.fields (fn c => c = NEWLINE_CHAR) ${str}"
+
+def lines(str: String): List[String] = unsafeLines(str).toList
+
+def split(str: String, sep: String): List[String] = unsafeSplit(str, sep).toList
+
+def exec(reg: Regex, str: String): Option[Match] = {
+  val matched = reg.unsafeMatchPrefix(str.chars)
+  if (matched.isDefined) { Some(Match(matched.force.getMatch())) }
+  else { None() }
+}

package/licenses/THIRD-PARTY.txt

@@ -0,0 +1,21 @@
+
+Lists of 19 third-party dependencies.
+     (The Apache Software License, Version 2.0) FindBugs-jsr305 (com.google.code.findbugs:jsr305:3.0.2 - http://findbugs.sourceforge.net/)
+     (Apache-2.0) Gson (com.google.code.gson:gson:2.8.9 - https://github.com/google/gson/gson)
+     (Apache 2.0) error-prone annotations (com.google.errorprone:error_prone_annotations:2.2.0 - http://nexus.sonatype.org/oss-repository-hosting.html/error_prone_parent/error_prone_annotations)
+     (The Apache Software License, Version 2.0) Guava InternalFutureFailureAccess and InternalFutures (com.google.guava:failureaccess:1.0.1 - https://github.com/google/guava/failureaccess)
+     (The Apache Software License, Version 2.0) Guava: Google Core Libraries for Java (com.google.guava:guava:27.1-jre - https://github.com/google/guava/guava)
+     (The Apache Software License, Version 2.0) Guava ListenableFuture only (com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava - https://github.com/google/guava/listenablefuture)
+     (The Apache Software License, Version 2.0) J2ObjC Annotations (com.google.j2objc:j2objc-annotations:1.1 - https://github.com/google/j2objc/)
+     (The BSD License) JLine (jline:jline:2.14.6 - http://nexus.sonatype.org/oss-repository-hosting.html/jline)
+     (The MIT License) Checker Qual (org.checkerframework:checker-qual:2.5.2 - https://checkerframework.org)
+     (MIT license) Animal Sniffer Annotations (org.codehaus.mojo:animal-sniffer-annotations:1.17 - http://www.mojohaus.org/animal-sniffer/animal-sniffer-annotations)
+     (Eclipse Public License, Version 2.0) LSP4J (org.eclipse.lsp4j:org.eclipse.lsp4j:0.12.0 - https://github.com/eclipse/lsp4j)
+     (Eclipse Public License, Version 2.0) LSP4J Generator (org.eclipse.lsp4j:org.eclipse.lsp4j.generator:0.12.0 - https://github.com/eclipse/lsp4j)
+     (Eclipse Public License, Version 2.0) LSP4J JSON-RPC (org.eclipse.lsp4j:org.eclipse.lsp4j.jsonrpc:0.12.0 - https://github.com/eclipse/lsp4j)
+     (Eclipse Public License, Version 2.0) Eclipse Xtend Runtime Library (org.eclipse.xtend:org.eclipse.xtend.lib:2.24.0 - https://www.eclipse.org/Xtext/)
+     (Eclipse Public License, Version 2.0) Eclipse Xtend Active Annotations Library (org.eclipse.xtend:org.eclipse.xtend.lib.macro:2.24.0 - https://www.eclipse.org/Xtext/)
+     (Eclipse Public License, Version 2.0) Eclipse Xbase Runtime Library (org.eclipse.xtext:org.eclipse.xtext.xbase.lib:2.24.0 - https://www.eclipse.org/Xtext/)
+     (MIT License) scallop (org.rogach:scallop_3:4.1.0 - https://github.com/scallop/scallop)
+     (Apache-2.0) Scala Library (org.scala-lang:scala-library:2.13.5 - https://www.scala-lang.org/)
+     (Apache-2.0) scala3-library-bootstrapped (org.scala-lang:scala3-library_3:3.0.0 - https://github.com/lampepfl/dotty)

package/licenses/apache-2.0 - license-2.0.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.