erokhins

trait A {
    private fun foo()
    fun bar() {
        foo()
    }
}

class B: A {}

fun main(args: Array<String>) {

erokhins

public final class Attrs<out T: HtmlTag>(tag: T): AbstractCommonAttribute<Attrs<T>>(tag)

open class A(containingTag: HtmlBodyTag): AllowText, HtmlBodyTag(containingTag, "a") {
//    public final class Attrs(htmlTag: HtmlTag): AbstractCommonAttribute<Attrs>(htmlTag)
    public open val attr: Attrs<A> = Attrs(this)
}
public var Attrs<A>.href: Link by Attributes.href

class A1: A("") {

erokhins

open class TagAttributes
    var TagAttributes.id = ""

class Tag<out T: TagAttributes>(val containingTag: Tag<TagAttributes>?, val t: T) {
    val attr: T = t
    fun attr(f: T.() -> Unit) {

    }
}

erokhins

open class A(open val bar: Int = 5) {
    {
        println("A: " + bar)
    }
}

class B(override val bar: Int = 2) : A() {
    {
        println("B: " + bar)

erokhins

open class A() {
    open fun bar(t: Int = 1) = t
}

class B: A() {
    override fun bar(t: Int): Int {
        return super.bar()
    }
}

erokhins

open class A {
  open val bar: Int
  {
    bar = 3
    println(bar)
  }
}

class B : A() {
  override val bar = 4

erokhins

public class Test {
    private static class A {
        private int bar;
        private A() {
            bar = 3;
            System.out.println(getBar());
        }

        public int getBar() {
            return bar;

erokhins

trait Inv<T> {
    var t: T
}

fun <T> some(t: Inv<T>): Inv<Inv<T>> {
    return object : Inv<Inv<T>> {
        override var t: Inv<T>
            get() = t
            set(value: Inv<T>) {
                t.t = value.t

erokhins

\documentclass[10pt]{article}
\usepackage[utf8]{inputenc}
\usepackage[english,russian]{babel}
\inputencoding{utf8}
\usepackage{amsmath}
\usepackage{amsthm}
\usepackage{amssymb}

\newcommand{\Expect}{\mathbb E}
\newcommand{\PRob}{\mathbb P}

erokhins

fun bar(s: List<String>) {}

fun test() {
    bar(listOf().filter { false })
}