Skip to main content
Version: v1.16.0

Refined Network Types

Import​

import refined4s.types.all.*

Refined Uri​

Uri is a refined String type that accepts only valid URI values.

Compile-time Validation​

Uri("https://www.google.com")
// res0: Type = "https://www.google.com"
Uri("https://github.com/kevin-lee")
// res1: Type = "https://github.com/kevin-lee"
Uri("%^<>[]`{}")
// error:
// Invalid value: ["%^<>[]`{}"]. It must be a URI String

Runtime Validation​

val validUri1 = "https://www.google.com" 
// validUri1: String = "https://www.google.com"
Uri.from(validUri1)
// res2: Either[String, Uri] = Right(value = "https://www.google.com")

val validUri2 = "https://github.com/kevin-lee" 
// validUri2: String = "https://github.com/kevin-lee"
Uri.from(validUri2)
// res3: Either[String, Uri] = Right(value = "https://github.com/kevin-lee")
val invalidUri = "%^<>[]`{}" 
// invalidUri: String = "%^<>[]`{}"
Uri.from(invalidUri)
// res4: Either[String, Uri] = Left(
//   value = "Invalid Uri value: [%^<>[]`{}]. Malformed escape pair at index 0: %^<>[]`{}"
// )

Get Value​

val uriA = Uri("https://www.google.com")
// uriA: Type = "https://www.google.com"
val uriB = Uri("https://github.com/kevin-lee")
// uriB: Type = "https://github.com/kevin-lee"

uriA.value
// res5: String = "https://www.google.com"

uriB.value
// res6: String = "https://github.com/kevin-lee"

Convert to java.net.URI​

uriA.toURI
// res7: URI = https://www.google.com

uriB.toURI
// res8: URI = https://github.com/kevin-lee

Refined Url​

Url is a refined String type that accepts only valid URL values with supported protocols.

Compile-time Validation​

Url("https://www.google.com")
// res9: Type = "https://www.google.com"
Url("https://github.com/kevin-lee")
// res10: Type = "https://github.com/kevin-lee"
Url("blah://test.com")

// Url("blah://test.com")
// ^^^^^^^^^^^^^^^^^^^^^^
// Invalid Url value: [blah://test.com]. unknown protocol: blah

Runtime Validation​

val validUrl1 = "https://www.google.com" 
// validUrl1: String = "https://www.google.com"
Url.from(validUrl1)
// res11: Either[String, Url] = Right(value = "https://www.google.com")

val validUrl2 = "https://github.com/kevin-lee" 
// validUrl2: String = "https://github.com/kevin-lee"
Url.from(validUrl2)
// res12: Either[String, Url] = Right(value = "https://github.com/kevin-lee")
val invalidUrl = "%^<>[]`{}" 
// invalidUrl: String = "%^<>[]`{}"
Url.from(invalidUrl)
// res13: Either[String, Url] = Left(
//   value = "Invalid Url value: [%^<>[]`{}]. no protocol: %^<>[]`{}"
// )

Get Value​

val urlA = Url("https://www.google.com")
// urlA: Type = "https://www.google.com"
val urlB = Url("https://github.com/kevin-lee")
// urlB: Type = "https://github.com/kevin-lee"

urlA.value
// res14: String = "https://www.google.com"

urlB.value
// res15: String = "https://github.com/kevin-lee"

Convert to java.net.URI​

urlA.toURI
// res16: URI = https://www.google.com

urlB.toURI
// res17: URI = https://github.com/kevin-lee

Refined PortNumber​

PortNumber is a refined Int type for valid TCP/UDP port numbers in the range 0 to 65535.

Compile-time Validation​

PortNumber(0)
// res18: Type = 0

PortNumber(65535)
// res19: Type = 65535
PortNumber(-1)
// PortNumber(-1)
// ^^^^^^^^^^^^^^
// Invalid value: [-1]. It has to be Int between 0 and 65535 (0 <= PortNumber <= 65535)


PortNumber(65536)
// PortNumber(65536)
// ^^^^^^^^^^^^^^^^^
// Invalid value: [65536]. It has to be Int between 0 and 65535 (0 <= PortNumber <= 65535)

Runtime Validation​

val validPortNumber1 = 0
// validPortNumber1: Int = 0
PortNumber.from(validPortNumber1)
// res20: Either[String, Type] = Right(value = 0)

val validPortNumber2 = 65535
// validPortNumber2: Int = 65535
PortNumber.from(validPortNumber2)
// res21: Either[String, Type] = Right(value = 65535)
val invalidPortNumber1 = -1
// invalidPortNumber1: Int = -1
PortNumber.from(invalidPortNumber1)
// res22: Either[String, Type] = Left(
//   value = "Invalid value: [-1]. It has to be Int between 0 and 65535 (0 <= PortNumber <= 65535)"
// )

val invalidPortNumber2 = 65536
// invalidPortNumber2: Int = 65536
PortNumber.from(invalidPortNumber2)
// res23: Either[String, Type] = Left(
//   value = "Invalid value: [65536]. It has to be Int between 0 and 65535 (0 <= PortNumber <= 65535)"
// )

Get Value​

val portNumberA = PortNumber(80)
// portNumberA: Type = 80
val portNumberB = PortNumber(9000)
// portNumberB: Type = 9000

portNumberA.value
// res24: Int = 80

portNumberB.value
// res25: Int = 9000

Refined SystemPortNumber​

SystemPortNumber is a refined Int type for system ports in the range 0 to 1023.

Compile-time Validation​

SystemPortNumber(0)
// res26: Type = 0

SystemPortNumber(1023)
// res27: Type = 1023
SystemPortNumber(-1)
// SystemPortNumber(-1)
// ^^^^^^^^^^^^^^^^^^^^
// Invalid value: [-1]. It has to be Int between 0 and 1023 (0 <= SystemPortNumber <= 1023)


SystemPortNumber(1024)
// SystemPortNumber(1024)
// ^^^^^^^^^^^^^^^^^^^^^^
// Invalid value: [1024]. It has to be Int between 0 and 1023 (0 <= SystemPortNumber <= 1023)

Runtime Validation​

val validSystemPortNumber1 = 0
// validSystemPortNumber1: Int = 0
SystemPortNumber.from(validSystemPortNumber1)
// res28: Either[String, Type] = Right(value = 0)

val validSystemPortNumber2 = 1023
// validSystemPortNumber2: Int = 1023
SystemPortNumber.from(validSystemPortNumber2)
// res29: Either[String, Type] = Right(value = 1023)
val invalidSystemPortNumber1 = -1
// invalidSystemPortNumber1: Int = -1
SystemPortNumber.from(invalidSystemPortNumber1)
// res30: Either[String, Type] = Left(
//   value = "Invalid value: [-1]. It has to be Int between 0 and 1023 (0 <= SystemPortNumber <= 1023)"
// )

val invalidSystemPortNumber2 = 1024
// invalidSystemPortNumber2: Int = 1024
SystemPortNumber.from(invalidSystemPortNumber2)
// res31: Either[String, Type] = Left(
//   value = "Invalid value: [1024]. It has to be Int between 0 and 1023 (0 <= SystemPortNumber <= 1023)"
// )

Get Value​

val systemPortNumberA = SystemPortNumber(22)
// systemPortNumberA: Type = 22
val systemPortNumberB = SystemPortNumber(80)
// systemPortNumberB: Type = 80

systemPortNumberA.value
// res32: Int = 22

systemPortNumberB.value
// res33: Int = 80

Refined NonSystemPortNumber​

NonSystemPortNumber is a refined Int type for non-system ports in the range 1024 to 65535.

Compile-time Validation​

NonSystemPortNumber(1024)
// res34: Type = 1024

NonSystemPortNumber(65535)
// res35: Type = 65535
NonSystemPortNumber(1023)
// NonSystemPortNumber(1023)
// ^^^^^^^^^^^^^^^^^^^^^^^^^
// Invalid value: [1023]. It has to be Int between 1024 and 65535 (1024 <= NonSystemPortNumber <= 65535)


NonSystemPortNumber(65536)
// NonSystemPortNumber(65536)
// ^^^^^^^^^^^^^^^^^^^^^^^^^^
// Invalid value: [65536]. It has to be Int between 1024 and 65535 (1024 <= NonSystemPortNumber <= 65535)

Runtime Validation​

val validNonSystemPortNumber1 = 1024
// validNonSystemPortNumber1: Int = 1024
NonSystemPortNumber.from(validNonSystemPortNumber1)
// res36: Either[String, Type] = Right(value = 1024)

val validNonSystemPortNumber2 = 65535
// validNonSystemPortNumber2: Int = 65535
NonSystemPortNumber.from(validNonSystemPortNumber2)
// res37: Either[String, Type] = Right(value = 65535)
val invalidNonSystemPortNumber1 = 1023
// invalidNonSystemPortNumber1: Int = 1023
NonSystemPortNumber.from(invalidNonSystemPortNumber1)
// res38: Either[String, Type] = Left(
//   value = "Invalid value: [1023]. It has to be Int between 1024 and 65535 (1024 <= NonSystemPortNumber <= 65535)"
// )

val invalidNonSystemPortNumber2 = 65536
// invalidNonSystemPortNumber2: Int = 65536
NonSystemPortNumber.from(invalidNonSystemPortNumber2)
// res39: Either[String, Type] = Left(
//   value = "Invalid value: [65536]. It has to be Int between 1024 and 65535 (1024 <= NonSystemPortNumber <= 65535)"
// )

Get Value​

val nonSystemPortNumberA = NonSystemPortNumber(8080)
// nonSystemPortNumberA: Type = 8080
val nonSystemPortNumberB = NonSystemPortNumber(54321)
// nonSystemPortNumberB: Type = 54321

nonSystemPortNumberA.value
// res40: Int = 8080

nonSystemPortNumberB.value
// res41: Int = 54321

Refined UserPortNumber​

UserPortNumber is a refined Int type for user (registered) ports in the range 1024 to 49151.

Compile-time Validation​

UserPortNumber(1024)
// res42: Type = 1024

UserPortNumber(49151)
// res43: Type = 49151
UserPortNumber(1023)
// UserPortNumber(1023)
// ^^^^^^^^^^^^^^^^^^^^
// Invalid value: [1023]. It has to be Int between 1024 and 49151 (1024 <= UserPortNumber <= 49151)


UserPortNumber(49152)
// UserPortNumber(49152)
// ^^^^^^^^^^^^^^^^^^^^^
// Invalid value: [49152]. It has to be Int between 1024 and 49151 (1024 <= UserPortNumber <= 49151)

Runtime Validation​

val validUserPortNumber1 = 1024
// validUserPortNumber1: Int = 1024
UserPortNumber.from(validUserPortNumber1)
// res44: Either[String, Type] = Right(value = 1024)

val validUserPortNumber2 = 49151
// validUserPortNumber2: Int = 49151
UserPortNumber.from(validUserPortNumber2)
// res45: Either[String, Type] = Right(value = 49151)
val invalidUserPortNumber1 = 1023
// invalidUserPortNumber1: Int = 1023
UserPortNumber.from(invalidUserPortNumber1)
// res46: Either[String, Type] = Left(
//   value = "Invalid value: [1023]. It has to be Int between 1024 and 49151 (1024 <= UserPortNumber <= 49151)"
// )

val invalidUserPortNumber2 = 49152
// invalidUserPortNumber2: Int = 49152
UserPortNumber.from(invalidUserPortNumber2)
// res47: Either[String, Type] = Left(
//   value = "Invalid value: [49152]. It has to be Int between 1024 and 49151 (1024 <= UserPortNumber <= 49151)"
// )

Get Value​

val userPortNumberA = UserPortNumber(8888)
// userPortNumberA: Type = 8888
val userPortNumberB = UserPortNumber(33333)
// userPortNumberB: Type = 33333

userPortNumberA.value
// res48: Int = 8888

userPortNumberB.value
// res49: Int = 33333

Refined DynamicPortNumber​

DynamicPortNumber is a refined Int type for dynamic/private ports in the range 49152 to 65535.

Compile-time Validation​

DynamicPortNumber(49152)
// res50: Type = 49152

DynamicPortNumber(65535)
// res51: Type = 65535
DynamicPortNumber(49151)
// DynamicPortNumber(49151)
// ^^^^^^^^^^^^^^^^^^^^^^^^
// Invalid value: [49151]. It has to be Int between 49152 and 65535 (49152 <= DynamicPortNumber <= 65535)


DynamicPortNumber(65536)
// DynamicPortNumber(65536)
// ^^^^^^^^^^^^^^^^^^^^^^^^
// Invalid value: [65536]. It has to be Int between 49152 and 65535 (49152 <= DynamicPortNumber <= 65535)

Runtime Validation​

val validDynamicPortNumber1 = 49152
// validDynamicPortNumber1: Int = 49152
DynamicPortNumber.from(validDynamicPortNumber1)
// res52: Either[String, Type] = Right(value = 49152)

val validDynamicPortNumber2 = 65535
// validDynamicPortNumber2: Int = 65535
DynamicPortNumber.from(validDynamicPortNumber2)
// res53: Either[String, Type] = Right(value = 65535)
val invalidDynamicPortNumber1 = 49151
// invalidDynamicPortNumber1: Int = 49151
DynamicPortNumber.from(invalidDynamicPortNumber1)
// res54: Either[String, Type] = Left(
//   value = "Invalid value: [49151]. It has to be Int between 49152 and 65535 (49152 <= DynamicPortNumber <= 65535)"
// )

val invalidDynamicPortNumber2 = 65536
// invalidDynamicPortNumber2: Int = 65536
DynamicPortNumber.from(invalidDynamicPortNumber2)
// res55: Either[String, Type] = Left(
//   value = "Invalid value: [65536]. It has to be Int between 49152 and 65535 (49152 <= DynamicPortNumber <= 65535)"
// )

Get Value​

val dynamicPortNumberA = DynamicPortNumber(55555)
// dynamicPortNumberA: Type = 55555
val dynamicPortNumberB = DynamicPortNumber(65432)
// dynamicPortNumberB: Type = 65432

dynamicPortNumberA.value
// res56: Int = 55555

dynamicPortNumberB.value
// res57: Int = 65432