# Kotlin

To use this language, use the class "language-kotlin".

## Numbers

    123
    123L
    0x0F
    0b00001011
    123.5
    123.5e10
    123.5f
    123.5F

## Strings and interpolation

    '2'
    '\uFF00'
    '\''

    "foo $bar \"baz"
    """
    foo ${40 + 2}
    baz${bar()}
    """

## Labels

    loop@ for (i in 1..100) {
      for (j in 1..100) {
        if (...)
          break@loop
      }
    }

## Annotations

    public class MyTest {
        lateinit var subject: TestSubject

        @SetUp fun setup() {
            subject = TestSubject()
        }

        @Test fun test() {
            subject.method()  // dereference directly
        }
    }

## Full example

    package com.example.html

    interface Element {
        fun render(builder: StringBuilder, indent: String)

        override fun toString(): String {
            val builder = StringBuilder()
            render(builder, "")
            return builder.toString()
        }
    }

    class TextElement(val text: String): Element {
        override fun render(builder: StringBuilder, indent: String) {
            builder.append("$indent$text\n")
        }
    }

    abstract class Tag(val name: String): Element {
        val children = arrayListOf<Element>()
        val attributes = hashMapOf<String, String>()

        protected fun initTag<T: Element>(tag: T, init: T.() -> Unit): T {
            tag.init()
            children.add(tag)
            return tag
        }

        override fun render(builder: StringBuilder, indent: String) {
            builder.append("$indent<$name${renderAttributes()}>\n")
            for (c in children) {
                c.render(builder, indent + "  ")
            }
            builder.append("$indent</$name>\n")
        }

        private fun renderAttributes(): String? {
            val builder = StringBuilder()
            for (a in attributes.keySet()) {
                builder.append(" $a=\"${attributes[a]}\"")
            }
            return builder.toString()
        }
    }

    abstract class TagWithText(name: String): Tag(name) {
        operator fun String.plus() {
            children.add(TextElement(this))
        }
    }

    class HTML(): TagWithText("html") {
        fun head(init: Head.() -> Unit) = initTag(Head(), init)

        fun body(init: Body.() -> Unit) = initTag(Body(), init)
    }

    class Head(): TagWithText("head") {
        fun title(init: Title.() -> Unit) = initTag(Title(), init)
    }

    class Title(): TagWithText("title")

    abstract class BodyTag(name: String): TagWithText(name) {
        fun b(init: B.() -> Unit) = initTag(B(), init)
        fun p(init: P.() -> Unit) = initTag(P(), init)
        fun h1(init: H1.() -> Unit) = initTag(H1(), init)
        fun a(href: String, init: A.() -> Unit) {
            val a = initTag(A(), init)
            a.href = href
        }
    }

    class Body(): BodyTag("body")

    class B(): BodyTag("b")
    class P(): BodyTag("p")
    class H1(): BodyTag("h1")
    class A(): BodyTag("a") {
        public var href: String
            get() = attributes["href"]!!
            set(value) {
                attributes["href"] = value
            }
    }

    fun html(init: HTML.() -> Unit): HTML {
        val html = HTML()
        html.init()
        return html
    }

## Known failures

There are certain edge cases where Prism will fail. There are always such cases in every regex-based syntax highlighter. However, Prism dares to be open and honest about them. If a failure is listed here, it doesn’t mean it will never be fixed. This is more of a “known bugs” list, just with a certain type of bug.

### Comment-like substrings

    "foo /* bar */";